Creación de datos falsos con Python Faker
Contenido
¿Cuál es la diferencia entre datos falsos y datos sintéticos?
Tanto los datos falsos como los datos sintéticos se utilizan para describir datos artificiales, pero existen diferencias importantes. Las diferencias radican en las características, los usos y los métodos de generación de datos.
La siguiente tabla muestra algunas de estas diferencias.
| datos falsos | Datos sintéticos | |
| Características | Valores aleatorios pero típicamente dentro de rangos normales. | Valores que tienen propiedades de distribución conjunta realistas. |
| Usos | Por lo general, se utiliza para probar bases de datos y software. | Se utiliza para aumentar conjuntos de datos reales para el entrenamiento de modelos, así como para garantizar la privacidad. |
| Métodos de generación | A menudo extraídos de bases de datos de valores o valores generados aleatoriamente. | Se pueden usar varios métodos de aprendizaje automático, incluidos modelos generativos antagónicos y codificadores automáticos variacionales. |
Al probar bases de datos y software antes de lanzar un sistema, no se han generado datos reales y, sin embargo, es importante probar los sistemas con más de unos pocos valores. Las pruebas de interfaz de usuario y las pruebas de rendimiento están incompletas sin tener cantidades realistas de datos en un sistema. Aquí es donde puede ser útil poder generar grandes cantidades de datos falsos rápidamente.
Hay muchos recursos disponibles para generar datos falsos. Varios se enumeran en Towards Data Science, algunos de los cuales son servicios que generan datos para usted, mientras que otros son bibliotecas de software. Este artículo se centrará en la biblioteca Python Faker y cubrirá varias técnicas que pueden ser útiles para comenzar.
Creación de datos falsos utilizando la biblioteca faker de Python.
Comenzar a usar Python Faker es sencillo. Use su administrador de paquetes favorito para instalar la biblioteca Faker y luego simplemente use las siguientes declaraciones para importar la biblioteca y crear un nuevo objeto Faker y establecer una semilla aleatoria:
from faker import Faker
fake = Faker()
Faker.seed(42)
Ahora tiene una instancia que puede usar para generar datos falsos. Establecer la semilla le permite volver a generar los mismos datos falsos. Cambiar la semilla le dará diferentes valores generados aleatoriamente.
Proveedores estándar
Ahora que tenemos una instancia, generemos algunos datos falsos utilizando los proveedores estándar de la biblioteca de Python Faker.
from faker import Faker
fake = Faker()
Faker.seed(42)
#Addresses
print(fake.address())
print(fake.building_number())
print(fake.city())
#Emails
print(fake.ascii_company_email())
print(fake.ascii_free_email())
#People
print(fake.name())
print(fake.first_name())
print(fake.last_name())
print(fake.first_name_female())
#Social Security Numbers
print(fake.ssn())
Puede ver lo fácil que es generar valores aleatorios que encajarían en los campos típicos de una base de datos. Hay muchos proveedores estándar que se pueden usar sin ningún parámetro para generar datos falsos rápida y fácilmente.
Proveedores estándar con rangos
A veces es necesario generar valores que se ajusten a rangos realistas. Por ejemplo, quizás las fechas válidas para un campo sean solo fechas de este siglo o esta década. O tal vez las fechas válidas están solo en el pasado o en el futuro. O tal vez necesite probar automáticamente un formulario de entrada de contraseña y las contraseñas generadas aleatoriamente deben cumplir con las reglas de complejidad de contraseñas de su organización.
El siguiente código demuestra algunas de las capacidades integradas de los proveedores estándar que limitan los rangos de resultados mientras siguen generando datos aleatorios.
from faker import Faker
fake = Faker()
Faker.seed(42)
#Dates within ranges
print(fake.date_this_century(before_today = True))
print(fake.date_this_decade(after_today = True))
print(fake.date_time_between(start_date="-7d", end_date="now"))
#Passwords
print(fake.password(length=16, special_chars=True, upper_case=True))
print(fake.password(length=8, special_chars=False, upper_case=False))
Generación de muchas filas de datos
En el código anterior hemos visto cómo generar valores únicos de varios tipos de datos utilizando Python Faker. En un escenario real, probablemente querríamos generar muchas filas de datos y dado que estamos trabajando en Python, probablemente querríamos estos datos en un Pandas DataFrame. El siguiente código se basa tanto en Pandas como en NumPy, por lo que si aún no los ha instalado en su entorno, deberá hacerlo antes de ejecutar este código.
from faker import Faker
import pandas as pd
import numpy as np
Faker.seed(42)
def generate_persons(num = 1):
fake = Faker()
rows = [{
'person_id':fake.uuid4(),
'first_name':fake.first_name(),
'last_name':fake.last_name(),
'address':fake.address(),
'dob':fake.date_of_birth(minimum_age = 18, maximum_age = 75),
'ssn':fake.ssn()
}
for x in range(num)]
return pd.DataFrame(rows)
persons = generate_persons(1000)
print(persons)
Puede modificar fácilmente este código para agregar diferentes columnas al DataFrame que se devuelve desde la función.
Generación de datos en escenarios más complejos
Si desea generar datos más realistas, probablemente ya tenga algunos datos para informar su definición de «realista». En estas situaciones, querrá utilizar datos sintéticos. Pero Python Faker se puede usar para generar datos que se ajustan a reglas simples y, aunque no se basan en datos reales, se pueden hacer para que parezcan realistas.
En el código de muestra a continuación, hemos modificado el generate_persons método de arriba para generar fechas de nacimiento que representan un conjunto de datos sesgados. Hacemos esto generando la distribución deseada de edades (principalmente jóvenes) y luego usando una función de utilidad de fecha, relativedelta, para crear fechas de nacimiento. Además, generamos aleatoriamente un booleano que marca ciertas filas como filas duplicadas y luego usamos la concatenación de Pandas para agregar estas filas duplicadas. Ambos hacen que los datos se parezcan más a algo que vería en un entorno del mundo real. Tenga en cuenta que el siguiente código usa matplotlib para mostrar la distribución de las fechas de nacimiento generadas, por lo que deberá asegurarse de que esta biblioteca esté instalada en su entorno antes de usar este código.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from faker import Faker
from dateutil.relativedelta import relativedelta
fake = Faker()
Faker.seed(42)
def generate_persons(num = 1):
ages = ((np.random.beta(3,8, size=num+1)) * 100).astype(np.int32)
rows = [{
"person_id":fake.uuid4(),
"first_name":fake.first_name(),
"last_name":fake.last_name(),
"dob":fake.date_this_year() - relativedelta(years = ages[x]),
"ssn":fake.ssn(),
"DUP":fake.boolean(5)
}
for x in range(num)]
return pd.DataFrame(rows)
persons = generate_persons(1000)
persons = pd.concat([persons, persons[persons["DUP"]]], ignore_index=True)
persons = persons.drop(columns=["DUP"])
print(persons)
print(plt.hist(persons['dob'], bins=20))
Aprende a programar con Udacity
Generar datos falsos con Python Faker es una gran habilidad para cualquier ingeniero de datos. En este artículo, aprendimos la diferencia entre datos falsos y sintéticos y aprendimos cómo generar una variedad de datos falsos utilizando la biblioteca Python Faker. Esta es una forma poderosa de generar grandes cantidades de datos rápidamente que se pueden usar para probar las interfaces de usuario y las bases de datos.
¿Quiere realmente llevar sus habilidades de ingeniería de datos al siguiente nivel?
Nuestro programa Programación para ciencia de datos con Python Nanodegree es su próximo paso. Te enseñaremos a trabajar en el campo de la ciencia de datos utilizando las herramientas fundamentales de programación de datos: Python, SQL, línea de comandos y git.
