Programación -CIENCIA DE DATOS UNIDAD 2 basico

Vista previa del material en texto

Fundamentos de programación para ciencia de datos:
A)Introducción a Python/R: entorno de trabajo y sintaxis básica.
 Python: Python es un lenguaje de programación versátil y de alto nivel que se ha vuelto muy popular en la comunidad de ciencia de datos. Tiene una sintaxis fácil de leer y escribir, lo que lo hace ideal para principiantes. Algunas características clave de Python son las siguientes:
Entorno de trabajo: Para trabajar con Python, puedes utilizar diferentes entornos de desarrollo integrados (IDE, por sus siglas en inglés), como PyCharm, Spyder o Jupyter Notebook. Estos entornos proporcionan un espacio de trabajo interactivo donde puedes escribir, ejecutar y probar tu código.
Sintaxis básica: La sintaxis básica de Python se caracteriza por su estructura clara y legible. Utiliza indentación en lugar de llaves para delimitar bloques de código, lo que fomenta la escritura de código limpio y bien organizado. Algunos conceptos clave incluyen variables, tipos de datos, estructuras de control (como condicionales y bucles) y funciones.
Ejemplo de sintaxis básica en Python:
# Declaración de una variable
nombre = "Juan"
# Estructura condicional
if edad >= 18:
 print("Eres mayor de edad")
else:
 print("Eres menor de edad")
----------------------------------------------------------------
# Bucle for
for i in range(1, 5):
 print(i)
 R: R es un lenguaje de programación y un entorno de software diseñado específicamente para el análisis estadístico y la visualización de datos. Es muy utilizado en la comunidad académica y de investigación. Algunas características clave de R son las siguientes:
Entorno de trabajo: El entorno de trabajo principal para R es RStudio, que es un IDE popular y fácil de usar. RStudio ofrece una interfaz gráfica y herramientas específicas para la programación en R, lo que facilita la escritura y ejecución de código.
Sintaxis básica: La sintaxis de R se basa en funciones y operaciones vectorizadas, lo que permite trabajar con conjuntos de datos de manera eficiente. R cuenta con una amplia variedad de paquetes y bibliotecas especializadas para diferentes tareas de análisis de datos.
Ejemplo de sintaxis básica en R:
# Declaración de un vector
edades <- c(25, 30, 35, 40)
-----------------------------------------------------------------
# Estructura condicional
if (edad >= 18) {
 print("Eres mayor de edad")
} else {
 print("Eres menor de edad")
}
----------------------------------------------------------------------
# Bucle for
for (i in 1:5) {
 print(i)
}
Funcionalidades y librerías disponibles en Python y R para el análisis de datos:
 Python:
NumPy: Es una librería fundamental para el cálculo numérico en Python. Proporciona una estructura de datos llamada "array" que permite realizar operaciones matemáticas de manera eficiente. Ejemplo de uso: cálculos numéricos, álgebra lineal, manipulación de matrices.
Pandas: Es una librería que ofrece estructuras de datos de alto rendimiento, como DataFrames, para el análisis y manipulación de datos. Permite la carga de datos desde diversos formatos (CSV, Excel, SQL, etc.) y proporciona herramientas para limpiar, transformar y filtrar los datos. Ejemplo de uso: exploración y manipulación de conjuntos de datos estructurados.
Matplotlib: Es una librería de visualización que permite crear gráficos estáticos, como gráficos de líneas, barras, dispersión, histogramas, entre otros. Proporciona opciones para personalizar los gráficos y crear visualizaciones de alta calidad. Ejemplo de uso: creación de gráficos para explorar y presentar datos.
Scikit-learn: Es una librería de aprendizaje automático (machine learning) en Python. Ofrece una amplia gama de algoritmos y herramientas para realizar tareas de clasificación, regresión, agrupamiento y selección de características. Ejemplo de uso: construcción y evaluación de modelos predictivos.
 R:
dplyr: Es una librería para el manejo y transformación de datos en R. Proporciona funciones sencillas y eficientes para filtrar, seleccionar, agregar y unir datos. Ejemplo de uso: manipulación de datos y preparación para análisis.
ggplot2: Es una librería de visualización en R que utiliza la gramática de los gráficos. Permitecrear gráficos elegantes y sofisticados mediante la especificación de capas estéticas y geométricas. Ejemplo de uso: creación de gráficos personalizados y visualización de patrones en los datos.
caret: Es una librería para aprendizaje automático en R que proporciona una interfaz unificada para diversos algoritmos y técnicas. Ofrece herramientas para preprocesamiento de datos, selección de modelos y evaluación de rendimiento. Ejemplo de uso: construcción y evaluación de modelos predictivos.
survival: Es una librería para el análisis de supervivencia en R. Permite realizar análisis de tiempo hasta el evento, como el cálculo de curvas de supervivencia, comparación de grupos y ajuste de modelos de riesgo proporcional de Cox. Ejemplo de uso: análisis de datos de supervivencia en estudios clínicos o estudios de tiempo hasta el fracaso.
Estos ejemplos solo rascan la superficie de las funcionalidades y librerías disponibles en Python y R para el análisis de datos. Ambos lenguajes cuentan con una gran comunidad y una extensa cantidad de librerías adicionales para prácticamente cualquier tarea de análisis
 B)Manipulación básica de datos: filtros, selección de columnas, etc.
Esta etapa implica la realización de operaciones para filtrar, seleccionar y transformar los datos según nuestras necesidades
ejemplos de técnicas comunes de manipulación de datos:
Filtros: Los filtros nos permiten seleccionar un subconjunto de datos basado en determinadas condiciones. Por ejemplo, en un conjunto de datos de ventas, podemos filtrar las filas para mostrar solo las ventas realizadas en un mes específico o por encima de cierto valor.
Ejemplo en Python con Pandas:
# Filtrar ventas mayores a $100
ventas_filtradas = df[df['monto'] > 100]
Selección de columnas: A veces, solo estamos interesados en ciertas columnas de un conjunto de datos. En este caso, podemos seleccionar esas columnas específicas para trabajar con ellas.
Ejemplo en R con dplyr:
# Seleccionar las columnas 'nombre' y 'edad'
datos_seleccionados <- select(datos, nombre, edad)
Ordenamiento: Podemos ordenar los datos según una o varias columnas en orden ascendente o descendente. Esto es útil cuando queremos ver los datos organizados de cierta manera.
Ejemplo en Python con Pandas:
# Ordenar los datos por columna 'fecha' en orden descendente
datos_ordenados = df.sort_values('fecha', ascending=False)
Agrupación y agregación: La agrupación nos permite dividir los datos en grupos basados en una o varias columnas y luego realizar agregaciones sobre cada grupo. Esto es útil para resumir y obtener información agregada de los datos.
Ejemplo en R con dplyr:
# Calcular el promedio de ventas por mes
ventas_promedio <- datos %>%
 group_by(mes) %>%
 summarise(promedio_ventas = mean(monto))
Estos son solo algunos ejemplos de las técnicas básicas de manipulación de datos. Tanto en Python como en R, existen numerosas librerías y herramientas que facilitan la manipulación y transformación de datos de manera eficiente y flexible
 C)Lectura y escritura de archivos de datos simples.
Estos archivos contienen información que queremos cargar en nuestro entorno de trabajo o guardar para su posterior uso.
ejemplos de cómo realizar la lectura y escritura de archivos de datos en Python y R:
Python:
Lectura de archivos CSV:
import pandas as pd
# Leer un archivo CSV
datos = pd.read_csv('archivo.csv')
------------------------------------------------------------------------------------------
Escritura de archivos CSV:
# Escribir datos en un archivo CSV
datos.to_csv('nuevo_archivo.csv', index=False)
----------------------------------------------------------------------------------------------
Lectura de archivos Excel:
# Leer un archivo Excel
datos = pd.read_excel('archivo.xlsx')
--------------------------------------------------------------------------------------
Escritura de archivos Excel:
# Escribir datos en un archivo Excel
datos.to_excel('nuevo_archivo.xlsx', index=False)
--------------------------------------------------------------------------------------
 R:
Lectura de archivos CSV:
# Leer un archivo CSV
datos <- read.csv('archivo.csv')
-------------------------------------------------------
Escritura de archivos CSV:
# Escribir datos en un archivo CSV
write.csv(datos, 'nuevo_archivo.csv', row.names=FALSE)
------------------------------------------------------------------------------------
Lectura de archivos Excel:
# Leer un archivo Excel
library(readxl)
datos <- read_excel('archivo.xlsx')
-------------------------------------------------------------------------------------------
Escritura de archivos Excel:
# Escribir datos en un archivo Excel
library(openxlsx)
write.xlsx(datos, 'nuevo_archivo.xlsx', row.names=FALSE)
-----------------------------------------------------------------------------------
Estos ejemplos muestran cómo leer y escribir archivos de datos en formato CSV y Excel, que son dos de los formatos más comunes. Sin embargo, tanto en Python como en R, existen muchas más opciones y formatos compatibles para la lectura y escritura de datos, como archivos JSON, archivos de texto plano, bases de datos, entre otros.
Recuerda adaptar el código según el formato de archivo y las bibliotecas específicas que estés utilizando. La lectura y escritura de archivos es una habilidad esencial en el análisis de datos, ya que te permite acceder a datos externos y guardar tus resultados de manera organizada para futuros análisis.
 Introducción al análisis de datos:
 A)Métodos básicos de análisis: sumarización de datos, conteo, agrupación, etc.
En esta sección, nos adentraremos en la introducción al análisis de datos y exploraremos algunos métodos básicos que te permitirán obtener información resumida y realizar operaciones de conteo y agrupación. A continuación, te mostraré ejemplos de estos métodos en Python y R:Python:
Sumarización de datos:
import pandas as pd
# Calcular la suma de una columna
suma_total = df['columna'].sum()
----------------------------------------------------------------------------------------
 ()Conteo de datos:
# Contar los valores únicos en una columna
conteo_valores = df['columna'].nunique()
# Contar la frecuencia de cada valor en una columna
frecuencia_valores = df['columna'].value_counts()
-------------------------------------------------------------------
Agrupación de datos:
# Agrupar datos y calcular la suma por grupo
datos_agrupados = df.groupby('columna_grupo')['columna'].sum()
--------------------------------------------------------------------------------------------------------
 R:
Sumarización de datos:
# Calcular la suma de una columna
suma_total <- sum(datos$columna)
--------------------------------------------------------------
Conteo de datos:
# Contar los valores únicos en una columna
conteo_valores <- length(unique(datos$columna))
# Contar la frecuencia de cada valor en una columna
frecuencia_valores <- table(datos$columna)
----------------------------------------------------------------------------------------
Agrupación de datos:
# Agrupar datos y calcular la suma por grupo
datos_agrupados <- aggregate(columna ~ columna_grupo, data = datos, sum)
------------------------------------------------------------------------------------------------------------------
Estos son solo algunos ejemplos de los métodos básicos de análisis de datos. Con ellos, puedes obtener resúmenes estadísticos, contar valores únicos y realizar operaciones de agrupación para obtener información más detallada sobre tus datos. Además, tanto en Python como en R, existen numerosas librerías y métodos avanzados que te permitirán realizar análisis más complejos y profundos.
Recuerda adaptar los ejemplos según el nombre de tus columnas y el tipo de datos que estés utilizando. El análisis de datos es una parte fundamental de la ciencia de datos, ya que nos permite extraer información significativa y tomar decisiones basadas en evidencia a partir de nuestros conjuntos de datos.
 B)Introducción a los conceptos de aprendizaje automático: clasificación y regresión.
Clasificación: La clasificación es una técnica de aprendizaje automático que se utiliza cuando queremos predecir la pertenencia de un objeto a una categoría o clase específica. Algunos pasos clave para implementar un modelo de clasificación son los siguientes:
a) Preparación de los datos: Esto implica la limpieza y preprocesamiento de los datos, como el manejo de valores faltantes, codificación de variables categóricas y normalización de características.
b) Selección del modelo: Existen varios algoritmos de clasificación, como árboles de decisión, regresión logística, máquinas de vectores de soporte (SVM) y bosques aleatorios. La elección del modelo depende del problema y los datos específicos.
c) Entrenamiento del modelo: Utilizamos un conjunto de datos etiquetados (datos de entrenamiento) para entrenar el modelo y ajustar sus parámetros.
d) Evaluación del modelo: Una vez entrenado, evaluamos el rendimiento del modelo utilizando métricas como precisión, recall, exactitud y F1-score. Además, podemos utilizar técnicas como la validación cruzada para obtener estimaciones más robustas del rendimiento.
Ejemplo de implementación en Python utilizando la librería scikit-learn:
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
# Preparación de los datos
X = datos_entrenamiento.drop('etiqueta', axis=1)
y = datos_entrenamiento['etiqueta']
# División en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Selección y entrenamiento del modelo
modelo = DecisionTreeClassifier()
modelo.fit(X_train, y_train)
# Predicciones en el conjunto de prueba
predicciones = modelo.predict(X_test)
# Evaluación del modelo
precision = accuracy_score(y_test, predicciones)
Ejemplo de implementación en R utilizando la librería caret:
library(caret)
# Preparación de los datos
X <- datos_entrenamiento[, -ncol(datos_entrenamiento)]
y <- datos_entrenamiento[, ncol(datos_entrenamiento)]
# División en conjuntos de entrenamiento y prueba
set.seed(42)
train_indices <- createDataPartition(y, p=0.8, list=FALSE)
X_train <- X[train_indices, ]
y_train <- y[train_indices]
X_test <- X[-train_indices, ]
y_test <- y[-train_indices]
# Selección y entrenamiento del modelo
modelo <- train(X_train, y_train, method="rpart")
# Predicciones en el conjunto de prueba
predicciones <- predict(modelo, X_test)
# Evaluación del modelo
precision <- confusionMatrix(predicciones, y_test)$overall['Accuracy']
Regresión: La regresión es otra técnica de aprendizaje automático que se utiliza para estimar o predecir un valor numérico continuo a partir de variables de entrada. Algunos pasos clave para implementar un modelo de regresión son los siguientes:
a) Preparación de los datos: Al igual que en la clasificación, se realiza la limpieza y preprocesamiento de los datos, incluyendo el manejo de valores faltantes, codificación de variables categóricas y normalización de características.
b) Selección del modelo: Algunos algoritmos comunes para la regresión son la regresión lineal, regresión de Ridge, regresión de Lasso y bosques aleatorios.
c) Entrenamiento del modelo: Utilizamos un conjunto de datos con variables explicativas (X) y valores de respuesta (y) para entrenar el modelo y ajustar sus parámetros.
d) Evaluación del modelo: Evaluamos el rendimiento del modelo utilizando métricas como el error cuadrático medio (RMSE), el coeficiente de determinación (R²) y el error absoluto medio (MAE).
Ejemplo de implementación en Python utilizando la librería scikit-learn:
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# Preparación de los datos
X = datos_entrenamiento.drop('valor_respuesta', axis=1)
y = datos_entrenamiento['valor_respuesta']
# División en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Selección y entrenamiento del modelo
modelo = LinearRegression()
modelo.fit(X_train, y_train)
# Predicciones en el conjunto de prueba
predicciones = modelo.predict(X_test)
# Evaluación del modelo
rmse = mean_squared_error(y_test, predicciones, squared=False)
------------------------------------------------------------------------------------------------------------------------
 Ejemplo de implementación en R utilizando la librería caret:
library(caret)
# Preparación de los datos
X <- datos_entrenamiento[, -ncol(datos_entrenamiento)]
y <- datos_entrenamiento[, ncol(datos_entrenamiento)]
# División en conjuntos de entrenamiento y prueba
set.seed(42)
train_indices <- createDataPartition(y, p=0.8, list=FALSE)
X_train <- X[train_indices, ]
y_train <- y[train_indices]
X_test <- X[-train_indices, ]
y_test <- y[-train_indices]
# Selección y entrenamiento del modelo
modelo <- train(X_train, y_train, method="lm")
# Predicciones en el conjunto de prueba
predicciones <- predict(modelo, X_test)
# Evaluación del modelo
rmse <- sqrt(mean((y_test - predicciones)^2))
Recuerda que estos ejemplos son solo una introducción básica y que existen muchas más técnicas y herramientas avanzadas parael análisis de clasificación y regresión en Python y R. Explorar más a fondo estas librerías y métodos te permitirá construir modelos más sofisticados y obtener mejores resultados en tus proyectos de análisis de datos y aprendizaje automático.