necesitan datos para su trabajo diario. Por supuesto, podría ser para análisis de datos, predicción de datos, minería de datos, construcción de modelos de aprendizaje automático, etc. Todos estos están a cargo de los respectivos miembros del equipo y deben trabajar para identificar fuentes de datos relevantes y asociados con el negocio. problemas.

Fuentes de datos

Las fuentes de datos se pueden identificar de dos maneras diferentes.

• Aspectos funcionales
• Aspectos técnicos

1 Aspecto funcional

Con respecto a los aspectos funcionales, se puede subdividir en fuentes Primarias y Secundarias. Hablemos rápidamente de esto.

• Fuentes primarias: Datos en forma de documentos, detalles de una persona (Nombre Apellido/Dirección/Fecha de nacimiento/Número de teléfono/Número de pasaporte/Licencia de conducir/tarjeta Aadar/SSN/Número de identificación nacional y etc.,) 
• Fuentes secundarias:  Derivado de Primario. 

2 Aspectos técnicos

Ambos mencionados anteriormente no son más que en forma de forma no digital. Cuando los convertimos en formas significativas. luego tuvo la sensación de ritmo técnico. Entonces se le daría el camino a las divisiones inferiores.

• Relacional (modelo de datos relacionales)
• Multidimensional (modelo de datos OLAP)

Fuente de la imagen: autor

¿Qué es el manejo de datos?

Se refiere al conjunto de procesos, los analizaremos uno por uno en detalle junto con bibliotecas de python efectivas.

• Recopilación de datos
• Limpieza/limpieza de datos
• Preparación de datos
• Negociación de datos

Recopilación de datos (DC)

Declaraciones generales sobre “RECOPILACIÓN DE DATOS" es una intervención manual que consume mucho tiempo, pero en este mundo digital, sería desde una fuente de aplicación, una aplicación móvil, dispositivos IoT, etc., utilizando herramientas y tecnologías automatizadas.

• Realización de una campaña
• Investigación cuantitativa
• Entrevistas
• Observación e investigación
• Análisis de marketing/ventas en línea
• Redes Sociales
• IoT y IIoT

La recopilación de datos de Clientes/Consumidores/Usuarios finales es un proceso clave y una estrategia comercial para llegar a su público objetivo perfecto para mejorar su presencia en el mercado líder y el soporte. Por lo tanto, en los últimos años, las industrias están financiando para recopilar datos y redactar planes importantes para sus avances comerciales.

Fuente https://www.fotolog.com/steps-in-data-science-process/

¿Por qué es tan importante?

A partir de la recogida de datos,

• Podríamos analizar la información de nivel raíz e identificar a sus clientes existentes y potenciales en el mercado.
• Puede construir relaciones sólidas con los clientes y planificar su futuro espacio de marketing
• Los datos en formato digital eliminarían posibles sesgos

La recopilación de datos es el primer y principal paso en el ciclo de vida de Machine Learning (ML). específicamente para entrenar, probar y construir el modelo de ML correcto para abordar la declaración del problema. Los datos que recopilamos definirán el resultado de los sistemas de ML después de muchas iteraciones y el proceso, por lo que este proceso es muy importante para el equipo de Data Science (o) ML. Obviamente, existen múltiples desafíos durante este período, repasemos algunos de ellos aquí.

• Los datos recopilados deben estar relacionados con el enunciado del problema.
• Los datos inexactos faltantes, los valores nulos en las columnas y las imágenes irrelevantes o faltantes de la fuente darían lugar a una predicción errónea.
• El desequilibrio, una anomalía y los valores atípicos se están desviando de nuestro enfoque y nos llevan a la etapa subrepresentada de la construcción de modelos.

Estrategias para solucionar los desafíos y problemas con DC

• Conjuntos de datos previamente limpiados y disponibles gratuitamente. Si la declaración del problema se alinea con un conjunto de datos limpio y correctamente redactado, aproveche la experiencia existente de código abierto.
• Métodos de rastreo y raspado web para recopilar los datos utilizando bots y herramientas automatizadas.
• Datos privados. Los ingenieros de ML pueden crear sus propios datos cuando el volumen de datos requerido para entrenar el modelo es muy pequeño y no se alinea con la declaración del problema.
• Datos personalizados, las organizaciones pueden crear los datos.

Limpieza/limpieza de datos

En el ciclo de vida de ML, el 60% o más de esa línea de tiempo se demandará en preparación de datos, carga, limpieza/purificación, transformación y remodelación/reorganización.

Cuando comenzamos a mirar el Limpieza (o) Limpieza proceso, Python proporciona la siguiente lista de opciones.

• Técnicas de manejo de datos perdidos
• Transformación de Datos
• Métodos de manipulación

Técnicas de manejo de datos perdidos: El análisis de datos faltantes es una técnica muy común en el mundo de ML. La falta de datos afecta el análisis y el modelo. Ciertamente, el modelo no podría entrenarse adecuadamente y desviar la predicción o el pronóstico en un punto posterior.

En los pandas de Python, usamos para adaptar NA (No disponible o No existe)

(i) Encontrar valores nulos

Mostraré algunos códigos de muestra aquí.

(a) Salida: si es un elemento nulo en la lista, debe ser Yaya

importar pandas como pd import numpy as np string_collection=pd.Series(['Apple','Ball','Cat',np.nan,'Dog'])

colección_de_cadenas

0 Apple
1 Bola
2 Cat
3 Yaya
Perro xnumx
dtype: objeto

(b) Salida: si es un elemento nulo en la lista, debe ser ¿Editas con tu equipo de forma remota?

colección_de_cadenas.isnull()

0 Falso

1 Falso

2 Falso

3 ¿Editas con tu equipo de forma remota?

4 Falso

dtipo: booleano

(c) Eliminar NaN de la lista

colección_cadenas.dropna()

0 Apple
1 Bola
2 Cat
Perro xnumx
dtype: objeto

(d) Intentemos con el conjunto de datos titánico

importar numpy como np

importar pandas como pd

importar matplotlib.pyplot como plt

importar seaborn como sns

% matplotlib en línea

df_titanic = pd.read_csv('titanic.csv')

df_titanic.cabeza()

df_titanic.isnull().cualquier()

(d) Número de nulos en la(s) columna(s)

print("Número de Null en la columna de edad:",df_titanic['edad'].isnull().sum()) print("Número de Null en la columna de la ciudad de embarque:",df_titanic['embark_town'].isnull(). suma())

Número de nulos en la columna de edad: 177
Número de nulos en la columna de la ciudad de embarque: 2

(e) Valores nulos a través de mapa de calor

sns.heatmap(df_titanic.isnull(),yticklabels=Falso,cbar=Falso,cmap='viridis')

(ii) Filtrado de los datos que faltan: hay dos formas de filtrar los valores que faltan, ya sea utilizando dropna o notnull.

• dropna: eliminará la fila del conjunto de datos/serie
• notnull: los datos seguirán estando en el conjunto de datos/serie

Métodos de manejo de NaN en pandas

Uso

(a) Filtrado usando filas Notnull/ Dropna

importar pandas como pd importar numpy como np desde numpy importar nan como NA data=pd.Series([100,250,NA,350,400,500,NA,950]) print(data) print("Aplicar dropna") print("==== =========") print(data.dropna() ) print("Aplicar notnull") print("=============") print(data[data. no nulo()])

Salida

0 100.0 1 250.0 2 NaN 3 350.0 4 400.0 5 500.0 6 NaN 7 950.0 dtype: float64 Aplicar dropna ============= 0 100.0 1 250.0 3 350.0 4 400.0 5 500.0 7 d type: float950.0 Aplicar notnull ============= 64 0 100.0 1 250.0 3 350.0 4 400.0 5 500.0 7 dtype: float950.0

(iii) Filtrado de la NA del marco de datos

importar pandas como pd importar numpy como np de numpy importar nan como NA data=pd.DataFrame([[100,101,102],['Raj','John',NA],[NA,NA,NA],['Chennai', 'Bangalore','Delhi']]) imprimir(datos)

Salida

 0 1 2 0 100 101 102 1 Raj John NaN 2 NaN NaN NaN 3 Chennai Bangalore Delhi

(iv) Limpieza NA

Cleand_data=data.dropna() print(Clean_data)

Salida

 0 1 2 0 100 101 102 3 Chennai Bangalore Delhi

Hasta ahora hemos hablado de filtrar los datos que faltan, pero la limpieza no es solo la solución. en un escenario en tiempo real, no podemos eliminar así sin la opinión de expertos en la materia (PYMES). Necesidad de completar los datos. hay varias técnicas están ahí. Vamos a discutir, algunos de ellos en este artículo.

importar pandas como pd importar numpy como np de numpy importar nan como NA data=pd.DataFrame([[100,101,102],['Raj','John','Jay'],[NA,NA,NA],['Chennai ','Bangalore','Delhi']])

datos.fillna(0)

Salida

(v) Complete los datos de la fila anterior

importar pandas como pd importar numpy como np de numpy importar nan como NA data=pd.DataFrame([['Raj','John','Jay'],[100,101,102],[NA,NA,NA],['Chennai ','Bangalore','Delhi']]) imprimir(datos)

Salida

 0 1 2 0 Raj John Jay 1 100 101 102 2 NaN NaN NaN 3 Chennai Bangalore Delhi

data.fillna(método='rellenar')

Verá esto desde el punto de vista de un marco de datos.

(vi) Eliminar filas duplicadas del marco de datos, simplemente usando drop_duplicates

importar pandas como pd importar numpy como np de numpy importar nan como NA data=pd.DataFrame([['Raj','Chennai'],['John','Chennai'],['Jey','Bangalore'] ,['Mohan','Delhi'],['Raj','Channai']]) imprimir(datos)

Salida

 0 1 0 Raj Chennai 1 John Chennai 2 Jey Bangalore 3 Mohan Delhi 4 Raj Channai

(vii) Encontrar duplicados

datos.duplicados()

0 Falso 1 Falso 2 Falso 3 Falso 4 Verdadero dtype: bool

datos.drop_duplicates()

(viii) Valores de sustitución

importar pandas como pd importar numpy como np de numpy importar nan como NA data=pd.DataFrame([['Raj','Chennai',0],['John','Chennai',2],['Jey', 'Bangalore',-1],['Mohan','Delhi',-3]]) imprimir(datos)

Salida

Con mean() en un conjunto de datos, considere que el auto-mpg dado tiene valores nulos en la columna de potencia y algunos datos basura (como ?).

imprimir(df_cars["caballos de fuerza"].isna().sum())

Salida

19

Entonces, la columna de caballos de fuerza tiene 19 valores nulos, manejemos esto ahora.

df_cars.horsepower = df_cars.horsepower.str.replace('?','NaN').astype(float) df_cars.horsepower.fillna(df_cars.horsepower.mean(),inplace=True) df_cars.horsepower = df_cars.horsepower .astype(int) print("######################################## ###########################") print("Después de limpiar y convertir el tipo en el conjunto de datos") print("### ############################################## #################") df_cars.info()

Los valores nulos se reemplazan por la media de la columna de caballos de fuerza.

imprimir(df_cars["caballos de fuerza"].isna().sum())

Salida

0

¡Sí! ¡Lo hicimos! impresionante Ahora podríamos considerar que la columna de caballos de fuerza está limpia y sin errores.

Transformación de datos

(I) Filtrado de valores atípicos: En términos simples, podemos analizar la distribución de datos, identificar los valores atípicos y eliminarlos del conjunto de datos para evitar el sobreajuste o el ajuste insuficiente durante la evaluación del modelo. Encontrar matemáticamente los valores atípicos en un proceso realmente desafiante, seguramente usará técnicas de visualización que facilitarán la comprensión y mejorarán.

importar pandas como pd importar numpy como np importar matplotlib.pyplot como plt importar seaborn como sns importar pandas como pd importar numpy como np importar matplotlib.pyplot como plt importar seaborn como sns desde IPython.display importar mostrar importar statsmodels como sm desde scipy importar estadísticas df_cars = pd.read_csv("auto-mpg.csv") df_cars.horsepower = df_cars.horsepower.str.replace('?','NaN').astype(float) df_cars.horsepower.fillna(df_cars.horsepower.mean (),inplace=True) df_cars.horsepower = df_cars.horsepower.astype(int) sns.boxplot(x=df_cars["horsepower"])

Podríamos observar que hay un valor atípico (puntos)
después de la escala de 200 para la función de potencia. Eliminemos los valores atípicos
utilizando métodos matemáticos.

z_scores = stats.zscore(df_cars["caballos de fuerza"])

abs_z_puntuaciones = np.abs(z_puntuaciones) print(abs_z_puntuaciones)

Salida

[0.67155703 1.5895576 1.19612879 1.19612879 0.93384291 2.455101 3.03212994 2.900987 3.16327288 2.2452723 1.72070054 1.45841466 1.19612879 3.16327288 0.24644355 0.24644355 0.19398637 0.50872943 0.43004366 1.53164436 0.45627225 0.37758649 0.24644355 0.22567103 0.37758649 2.900987 2.50755818 2.76984406 2.32395806 0.43004366 0.37758649 0.24644355 0.01038626 0.11530061 0.01584233 0.11530061 0.43004366 0.11530061 1.5895576 1.85184348 1.27481455 1.19612879 1.98298642 1.72070054 1.85184348 0.14698527 0.84970107 0.11530061 0.43004366 0.48250084 0.37758649 0.90215825 0.74478672 1.03330119 0.92838683 1.16444413 0.90215825 0.24644355 0.63987237 1.32181565 0.37758649 0.48250084 1.5895576 1.85184348 1.19612879 1.27481455 1.19612879 2.71738688 1.32727172 1.45841466 2.2452723 0.19398637 1.19612879 0.67155703 0.93384291 1.19612879 0.19944245 0.74478672 0.45627225 0.92838683 0.48250084 0.32512931 0.19398637 0.63987237 0.43004366 1.85184348 1.19612879 1.06498585 0.85515714 1.19612879 2.455101 1.19612879 1.40595749 1.19612879 2.900987 3.16327288 1.85184348 0.01584233 0.11530061 0.11530061 0.43004366 0.24644355 1.53164436 1.19612879 1.64201478 1.72070054 1.98298642 0.11530061 0.43004366 0.84970107 0.27267214 0.37758649 0.50872943 0.06829951 0.37758649 1.06498585 3.29441582 1.45295859 0.77101531 0.3513579 0.19944245 1.19612879 0.14698527 0.46172832 1.98298642 0.24644355 0.01038626 0.11530061 0.11530061 0.98084401 0.63987237 1.03330119 0.77101531 0.11530061 0.14698527 0.01584233 0.93384291 1.19612879 1.19612879 0.93384291 1.19612879 0.5611866 0.98084401 0.69232954 1.37427283 1.13821554 0.77101531 0.77101531 0.77101531 0.19398637 0.29890072 0.98084401 0.24644355 0.01584233 0.84970107 0.84970107 1.72070054 1.06498585 1.19612879 1.14367161 0.14698527 0.01584233 0.14698527 0.24644355 0.14698527 0.14698527 0.64532844 0.77101531 0.5611866 0.11530061 0.69232954 0.22021496 0.87592966 0.19398637 0.19398637 0.90215825 0.37758649 0.24644355 0.43004366 0.16775779 0.27812821 1.34804424 0.48250084 0.61364378 0.32512931 0.66610096 0.5611866 0.93384291 1.19612879 0.40927115 1.24858596 0.11530061 0.01584233 0.61364378 0.37758649 1.37427283 1.16444413 0.90215825 1.34804424 0.11530061 0.69232954 0.14698527 0.24644355 0.87592966 0.90215825 0.77101531 0.84970107 0.06284343 1.19612879 0.43004366 0.09452809 0.40927115 1.98298642 1.06498585 0.67155703 1.19612879 0.95461542 0.63987237 1.2169013 0.22021496 0.90215825 1.06498585 0.14698527 1.06498585 0.67155703 0.14698527 0.01584233 0.11530061 0.16775779 1.98298642 1.72070054 2.2452723 1.1699002 0.69232954 0.43004366 0.77101531 0.40381508 1.08575836 0.5611866 0.98084401 0.69232954 0.19398637 0.14698527 0.14698527 1.47918718 1.0070726 1.37427283 0.90215825 1.16444413 0.14698527 0.93384291 0.90761432 0.01584233 0.24644355 0.50872943 0.43004366 0.11530061 0.37758649 0.01584233 0.50872943 0.14698527 0.40927115 1.06498585 1.5895576 0.90761432 0.93384291 0.95461542 0.24644355 0.19398637 0.77101531 0.24644355 0.01584233 0.50872943 0.19398637 0.03661485 0.54041409 0.27812821 0.75024279 0.87592966 0.95461542 0.27812821 0.50872943 0.43004366 0.37758649 0.14698527 0.67155703 0.64532844 0.88138573 0.80269997 1.32727172 0.98630008 0.54041409 1.19612879 0.87592966 1.03330119 0.63987237 0.63987237 0.71855813 0.54041409 0.87592966 0.37758649 0.90215825 0.90215825 1.03330119 0.92838683 0.37758649 0.27812821 0.27812821 0.37758649 0.74478672 1.16444413 0.90215825 1.03330119 0.37758649 0.43004366 0.37758649 0.37758649 0.69232954 0.37758649 0.77101531 0.32512931 0.77101531 1.03330119 0.01584233 1.03330119 1.47918718 1.47918718 0.98084401 0.98084401 0.98084401 0.01038626 0.98084401 1.11198695 0.7240142 0.11530061 0.43004366 0.01038626 0.84970107 0.53495802 0.53495802 0.32512931 0.14698527 0.53495802 1.2169013 1.05952977 1.16444413 0.98084401 1.03330119 1.11198695 0.95461542 1.08575836 1.03330119 1.03330119 0.79724389 0.01038626 0.77101531 0.77101531 0.11530061 0.79724389 0.63987237 0.74478672 0.3043568 0.40927115 0.14698527 0.01584233 0.43004366 0.50872943 0.43004366 0.43004366 0.43004366 0.50872943 0.53495802 0.37758649 0.32512931 0.01038626 0.79724389 0.95461542 0.95461542 1.08575836 0.90215825 0.43004366 0.77101531 0.90215825 0.98084401 0.98084401 0.98084401 0.14698527 0.50872943 0.32512931 0.19944245 0.22021496 0.53495802 0.37758649 0.48250084 1.37427283 0.53495802 0.66610096 0.58741519 0.69232954]

Puedo entender que esto es realmente todo, está bien, establezcamos un umbral y continuemos.

entradas_filtradas = (abs_z_scores < 1.5) new_df = df_cars[entradas_filtradas]

imprimir (nuevo_df)

MPG Cilindros de desplazamiento de caballos de caballos Aceleración de peso 0 18.0 8 307.0 130 3504 12.0 2 18.0 8 318.0 150 3436 11.0 3 16.0 8 304.0 150 3433 12.0 4 17.0 8 302.0 140 3449 10.5 11 14.0 8 340.0 160 3609 8.0 ... ... ... ... .. ... ... ... 394 44.0 4 97.0 52 2130 24.6 395 32.0 4 135.0 84 2295 11.6 396 28.0 4 120.0 79 2625 18.6 397 31.0 4 119.0 82 2720 19.4 398 Nan 4 250.0 78 2500 18.5 Model_year Nombre de origen 0 70.0 1.0 chevrolet chevelle malibu 2 70.0 1.0 plymouth satellite 3 70.0 1.0 amc rebel sst 4 70.0 1.0 ford torino 11 70.0 1.0 plymouth 'cuda 340 .. ... ... ... 394 82.0 2.0 camioneta vw 395 82.0 1.0 dod396ge rampa 82.0 1.0 ford ranger 397 82.0 1.0 chevy s-10 398 NaN NaN NaN [360 filas x 9 columnas]

sns.boxplot(x=nuevo_df["caballos de fuerza"])

Ahora, el diagrama de caja es muy claro y no tiene más
valores atípicos Piense en el poder de las bibliotecas de Python aquí.

(II) Tipo de conversión: Analizaremos el tipo de columnas del conjunto de datos dado, esta es una actividad esencial antes de realizar la ingeniería de características y el entrenamiento de prueba.

df_cars = pd.read_csv("auto-mpg.csv")

imprimir("########################################") imprimir ("Información del conjunto de datos") print("#################################### ######") df_coches.info()

Salida

Observación:
1. pudimos observar que las características y su tipo de datos, junto con el recuento Nulo
2. Las características de potencia y nombre son, Objeto en el conjunto de datos dado

Cómo transformar esto en una forma significativa para nuestro análisis. usando un tipo simple.

df_cars.horsepower = df_cars.horsepower.str.replace('?','NaN').astype(float) df_cars.horsepower.fillna(df_cars.horsepower.mean(),inplace=True) df_cars.horsepower = df_cars.horsepower .astype(int) print("######################################## ###########################") print("Después de limpiar y convertir el tipo en el conjunto de datos") print("### ############################################## #################") df_cars.info()

Salida

Observación:
1. pudimos observar que las características y su tipo de datos, junto con el recuento Nulo
2. Podríamos observar que ahora la potencia es de tipo int.

(III) Crear variables ficticias: En un escenario en tiempo real, tenemos que manejar la variable categórica de manera inteligente para que podamos acomodarlas en el proceso de convertirlas en variables ficticias y hacer uso de ellas como variables independientes. Veamos la muestra aquí.

df_coches.cabeza(5)

Vamos a convertirlos en una variable categórica.

df_cars['origen'] = df_cars['origen'].replace({1: 'america', 2: 'europe', 3: 'asia'}) df_cars.head()

cData = pd.get_dummies(df_cars, column=['origen']) cData

(III) Transformación de cadenas: En algunas situaciones, tenemos que lidiar con valores de cadena en el conjunto de datos dado y, como científicos de datos, somos responsables de optimizarlos para el análisis de datos. Aquí hay una muestra clásica que se enfrenta con mayor frecuencia.

patrón = 'chevroelt|chevy|chevrolet'

máscara = df_cars['nombre'].str.contains(patrón, caso=Falso, na=Falso)

df_cars[máscara].cabeza()

Observe aquí que Chevrolet en diferentes ortografías, por lo que durante el modelado de clasificación esto le daría dolor de cabeza y desafiaría su paciencia, ahora sígame, cómo podemos manejar esto.

# Nombre correcto df_cars['nombre'] = df_cars['nombre'].str.replace('chevroelt|chevrolet|chevy','chevrolet') df_cars['nombre'] = df_cars['nombre'].str.replace ('maxda|mazda','mazda') df_cars['nombre'] = df_cars['nombre'].str.replace('mercedes|mercedes-benz|mercedes benz','mercedes') df_cars['nombre'] = df_cars['nombre'].str.replace('toyota|toyouta','toyota') df_cars['nombre'] = df_cars['nombre'].str.replace('vokswagen|volkswagen|vw','volkswagen ')

El código anterior agilizará los nombres de marca y su modelado funcionará mejor que antes.

Veamos cómo funciona la transformación de cadenas aquí.

patrón = 'chevrolet' máscara = df_cars['nombre'].str.contains(patrón, caso=Falso, na=Falso) df_cars[máscara].head()

Espero que te guste esto, ¡Sí! Puedo entender.

Lea más artículos en nuestro sitio web sobre técnicas de manejo de datos. Hacer clic esta página.

Este es un viaje largo, hasta ahora cubrimos las técnicas posibles y más frecuentes en las técnicas de manejo de datos desde la recopilación de datos, la limpieza y los aspectos de disputa, aún así, existen muchas más técnicas y el uso depende de los casos. Con respecto a los datos La ciencia, el manejo de datos es un papel vital y el 60-65% del esfuerzo requeriría ajustar nuestros datos para el modelado. Así que recuerda que todas estas características que hemos discutido aquí ciertamente te ayudarán mucho. con todos ustedes en algo temas interesantes. Espero que les haya gustado mi artículo sobre técnicas de manejo de datos.

¡Gracias por su tiempo, buena suerte! Los veo pronto. – Shanthababu

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor. 

Relacionado:

• Coinsmart. El mejor intercambio de Bitcoin y criptografía de Europa.
• Platoblockchain. Inteligencia del Metaverso Web3. Conocimiento amplificado. ACCESO LIBRE.
• CriptoHawk. Radar de altcoins. Prueba gratis.
• Fuente: https://www.analyticsvidhya.com/blog/2022/01/a-detailed-guide-for-data-handling-techniques-in-data-science/