Introducción

Basándose en investigación y resultados de Deep Learning de última generación, Dedomena ha desarrollado algoritmos generativos propietarios basados en arquitecturas de redes neuronales profundas personalizadas, complementados con modelos de ML y probabilísticos, para abordar problemas como outliers de privacidad, variables de tipos de datos raros como descripciones de transacciones bancarias, entre otros, que generan datos sintéticos con la más alta calidad a partir de datos estructurados reales.

Los datos artificiales generados con Dedomena mantienen las estadísticas, distribuciones, patrones subyacentes, relaciones multivariadas y el valor relevante, haciendo posible reemplazar los datos reales y realizar análisis, probar aplicaciones o entrenar modelos de ML sobre ellos, por nombrar algunos casos de uso. Como efecto beneficioso de ser entidades y usuarios sintéticos, más nuestra capa extra de restricciones y validaciones de privacidad, los datos sintéticos resultantes están totalmente anonimizados, haciendo imposible re-identificar cualquier información, comportamiento, entidad o usuario a partir de los datos originales.

Dedomena provee dos enfoques para generar datos sintéticos según dónde se realice el cómputo de entrenamiento: completamente en la nube o híbrido. En ambos casos la generación de datos sintéticos se realiza en la nube, destacando que nuestro software se despliega y ejecuta solo en servidores europeos de Google Cloud en regiones con baja huella de carbono.

Nucleus es el componente principal de la plataforma de DEDOMENA.AI. Permite entrenar synthesizers que luego se usan para generar copias ilimitadas de datos sintéticos. Estos synthesizers pueden crearse en la plataforma de DEDOMENA.AI (cargando datos a través de la sección Axon) o en el entorno de la fuente de datos, a través del componente Nucleus Edge.

A través de Nucleus, las empresas en cualquier etapa pueden entrenar synthesizers con varios algoritmos con solo unos pocos parámetros o líneas de código, permitiendo la generación de datos sintéticos realistas para varios casos de uso.

Algoritmos

Dedomena ofrece 4 algoritmos de sintetización:

Generic: Aprende de datos tabulares estructurados de cualquier industria donde los patrones recurrentes u otros patrones complejos basados en fechas no son la característica principal que debe mantener el dato sintético. Este algoritmo provee la capacidad de hacer fine-tuning de synthesizers pre-entrenados.

Transactional: Aprende de datos basados en eventos/transacciones (time series irregulares o con intervalo de timestamp no constante entre eventos o transacciones). Este algoritmo fue pensado para ser usado con datasets transaccionales, por lo tanto hay ciertas columnas esenciales para que funcione correctamente. Aporta parámetros extra solo para datos transaccionales bancarios, como un tipo especial de dato transaccional, logrando un rendimiento superior generando transacciones bancarias con descripciones de texto, entre otras capacidades.

Timeseries: Como su nombre lo indica, se usa para aprender de datos que siguen una estructura de serie temporal con timestamps equidistantes. Variables como user/product id y fecha de la serie son obligatorias para garantizar excelentes resultados globales y por tipo de entidad. Es lo suficientemente flexible para aprender series temporales mensuales, semanales, diarias u horarias. Otras variables relacionadas con el evento/transacción también pueden aprenderse.

Relational: El algoritmo relacional está diseñado para sintetizar datasets multi-tabla. Deben cumplir las siguientes condiciones:

1. Todas las tablas deben estar conectadas de alguna forma. Las tablas desconectadas pueden sintetizarse por separado.

2. No debe haber referencias faltantes (también conocidas como orphan rows). Si la tabla A referencia a la tabla B, entonces cada referencia debe encontrarse. De lo contrario, la fila se eliminará y no se generará. Está bien si una fila padre no tiene hijos.

3. No puede haber referencias cíclicas. Una tabla no puede referenciarse a sí misma. O si la tabla A referencia a la tabla B, entonces la tabla B no puede referenciar de nuevo a la tabla A.

4. Cada foreign key debe ser primary key de la tabla a la que referencia.

Nucleus

Nucleus (Cloud)

Para generar datos sintéticos usando la versión cloud de Nucleus consulta: Quickstart.

Nucleus Edge

Nucleus Edge es una librería Python que puede descargarse desde la sección Edge en la pestaña NUCLEUS, permitiendo el despliegue flexible de múltiples nodos Nucleus en múltiples y diferentes entornos. El usuario solo necesita especificar el OS y la versión de Python (3.9 o 3.10). Desde esta vista se puede copiar el token necesario para hacer que la librería sea utilizable.

Instalación

Nucleus Edge permite a los usuarios instalar fácilmente el software de Dedomena y ejecutar corridas de sintetización necesitando solo un entorno Python, funcionando incluso en una laptop. Nucleus Edge es una librería Python como Pandas o Numpy.

Pasos:

• Instala pip si no está instalado

# Debian/Ubuntu

sudo apt update
sudo apt -y install python3-pip

• Crea un entorno Python: venv — Creation of virtual environments.

• Usa pip para instalar la librería Python de Nucleus Edge:

pip install nucleus-edge-2.0.1-python-39-x86_64-linux-gnu.tar.gz

• Crea una carpeta donde se persistirán los synthesizers (el nombre podría ser results por ejemplo) otorgando el acceso adecuado a los usuarios que usarán Nucleus Edge.

mkdir results
chmod 755 results

Configuración

Una vez que Nucleus Edge está instalado en el entorno Python, el usuario puede crear corridas de sintetización con solo unas pocas líneas de código. Se proveen varios parámetros de configuración y algoritmos para ajustar el proceso de sintetización a los datos y al caso de uso.

Estos parámetros incluyen algoritmo, batch size, número de epochs, imputar valores faltantes, entre otros. Opcionalmente, también puedes reemplazar nombres de columnas, decidir si hacer el cómputo en CPU o GPU, cambiar tipos de datos así como otras configuraciones del dataset y la corrida, permitiéndote generar datos limpios y útiles para cubrir necesidades específicas de datos.

Input: Nucleus Edge aceptará archivos en formato Parquet y CSV como datos de entrada.

Output: Un archivo encriptado que necesita subirse a la plataforma de Dedomena para generar datos sintéticos: se persiste en el results_dir definido. Este archivo NO incluye ninguna información original o dato sensible, solo contiene el synthesizer para generar datos artificiales.

Parámetros

Los siguientes parámetros son comunes a todos los algoritmos.

• data_dir: string. Path al archivo del dataset o base de datos. Ejemplos: "/myfolder/data_dir/file.csv", "postgresql://username:password@server:port/database". Fuentes de datos disponibles:

  • PostgreSQL
  • Oracle
  • SQLite
  • MySQL
  • MariaDB
  • Amazon Redshift
  • Microsoft SQL Server
  • Azure SQL Database
  • Google Cloud Big Query
  • IBM DB2

• data_format: string. Formato de datos de entrada. Cuatro opciones: CSV, PARQUET, MTX o DATABASE.

• token: string. El token provisto por Dedomena para hacer operativo Nucleus Edge.

• algorithm: string. 'generic', 'transactional', 'timeseries'.

• query: string. Solo disponible cuando data_format es DATABASE. Nombre de la tabla que quieres recuperar o consulta SQL para obtener los datos, por ejemplo, "SELECT * FROM table".

• batch_size: int (potencia de 2: 128, 256, 512, etc.). Tamaño de los batches.

• epochs: int (se recomiendan valores entre 100-300 para generic y transactional). Número de epochs.

• synthesizer_name: string. Nombre del synthesizer definido por el usuario.

• synthesizer_description: string. Descripción del synthesizer definida por el usuario.

• amplify: string. 'default', 'quality'. Solo para algoritmos generic y transactional. Cuando amplify='quality' boosteará la calidad del dato sintético disminuyendo levemente la privacidad del dato resultante respecto al dato usado para crear el synthesizer, obteniendo un synthesizer que generará mejor dato sintético respecto a la calidad del dato. Cuando se especifica, el número de epochs debe ser mayor o igual a 150. La configuración default siempre busca maximizar la privacidad.

• impute: bool. Imputar valores faltantes cuando es True. De lo contrario, aprenderá y mantendrá las distribuciones de los valores faltantes según la variable, generando datos sintéticos con valores faltantes según los datos originales.

• categorical_columns: array. Nombres de las columnas discretas en el dataset.

• date_columns: array o dict. Array con los nombres de las columnas de fecha en el dataset. Ejemplo: ['date_column_1', 'date_column2', ...]. Es posible especificar el string de formato para la columna de fecha pasando un diccionario con nombres de columnas como keys y string de formato como values, en lugar de un array con solo los nombres de columnas. Ejemplo: {'date_column1': 'str_format1', 'date_column2': 'str_format2', ...}. Debe usarse la siguiente notación.

• integer_columns: array. Nombres de las columnas enteras en el dataset.

• boolean_columns: array. Nombres de las columnas booleanas en el dataset.

• float_columns: array. Nombres de las columnas float en el dataset.

• text_columns: dictionary. Un diccionario que incluye el nombre de las columnas de texto en el dataset como keys y la instrucción para generar el texto para cada una como values, por ejemplo {'column_name': 'Replace hospital names in the text with '}. Si no se dan instrucciones, por defecto, la información de identificación personal (PII) se reemplaza con datos sintéticos. En este caso, debe usarse {'column_name': ' '}.

• coordinate_columns: array. Un array de diccionarios, cada uno especificando un par de nombres de columnas de latitud y longitud usando las keys 'latitude' y 'longitude', usado para identificar múltiples sets de coordenadas en los datos para generar coordenadas sintéticas. Ej: [{'latitude': 'column_lat1', 'longitude': 'column_lon1'}, {'latitude': 'variable_lat2', 'longitude': 'variable_lon2'}, ....].

• id_columns: dict. Un diccionario { 'column_name': 'regex_pattern' } para generar IDs sintéticos basados en una expresión regular; si 'regex_pattern' es None, se generan IDs numéricos secuenciales ordinales [0, 1, 2, …] en su lugar. Ej: { 'column_name1': 'ID_\d{4}', 'column_name2': None, 'column_name3': '[A-Z0-9]{10}'}.

• output_dir: string. Path donde se persistirá el archivo encriptado.

• max_categories: int. Número máximo de valores que debe tener una variable categórica. Si la variable tiene más categorías que el máximo, las menos comunes se asignarán a una nueva categoría "others".

• min_freq_categories: int. Número mínimo de valores que cualquier variable categórica debe tener. El resto de las categorías se agruparán en una sola categoría llamada "Others - DM".

• num_cat: int. Solo disponible cuando amplify='default'. Número de los valores más frecuentes a considerar como categóricos en variables numéricas. Se usa para generar con mejor precisión valores que aparecen frecuentemente en algunas variables numéricas como precios comunes, temperaturas, montos, el número cero, entre otros. Si es igual a 5 por ejemplo, tratará los 5 valores más frecuentes en la variable numérica como categóricos.

• cuda: bool. Cuando es True usará GPU para el cómputo (tiene que estar disponible en el sistema), de lo contrario CPU.

• target: string. Nombre de la variable target para evaluar el utility y predictive power score, basado en la definición clásica de machine learning de target. Si es None, el algoritmo selecciona un target aleatoriamente de las variables disponibles. Si el target es numérico, se crearán bins del mismo y se pasará como categórico. Dedomena ajusta algoritmos de ML baseline para analizar el utility y predictive power de los datos, por lo tanto en muchos escenarios reales el target deseado no es posible de predecir con las variables dependientes disponibles.

• columns_mapping: dict. Diccionario que especifica el mapping para los nombres de columnas para asignar qué columnas usar para: user_id, cat_id, concept, txn_date, amount, balance. Si no se especifica una columna, se buscará en el dataset con el nombre por defecto. El diccionario debe tener las siguientes keys equivalentes a la definición inicial.

• transform_descriptions: string. None, 'level1', 'level2', 'level3'. Solo disponible para algoritmos generic y transactional y una variable concept/description.

  • None: Las descripciones no se transformarán mientras se sintetizan y por lo tanto se generarán las mismas descripciones de los datos reales.
  • level1: Sintetizará fechas, números de tarjeta, números de cuenta (IBANs) y montos presentes en el texto de las descripciones.
  • level2: Todo lo de level1, además sintetizará nombres de personas, direcciones, ciudades, presentes en el texto de las descripciones.
  • level3: Todo lo de level2, además sintetizará nombres de comercios presentes en el texto de las descripciones. Generará comercios de industrias similares (ej: McDonalds / Burguer King / Five Guys, Iberia / Air Europe / Ryanair).

• balance_updated: bool o None. Solo para el algoritmo transactional. Si hay en los datos una variable de balance llamada "balance" y balance_updated=True, entonces el balance correspondiente a cada transacción se considerará actualizado, es decir, balance[i]=balance[i-1]+amount[i]. Si balance_updated=False, el balance se considerará no actualizado, balance[i]=balance[i-1]+amount[i-1]. Se considerará que no hay transacciones faltantes, es decir, todos los balances generados cumplirán una de las condiciones anteriores. Si balance_updated=None, el balance se considerará como una columna float.

• constraints: list. Lista de strings definiendo constraints entre columnas. Por ejemplo:

  • col1<->col2<->col3: Las columnas col1, col2 y col3 tienen combinaciones fijas, como description, subcategory y category. Puede definirse cualquier número de columnas.
  • col1<=col2: Todos los valores en col1 deben ser menores o iguales a col2.
  • col1>10: Todos los valores en col1 deben ser mayores a 10.
  • col1>0: Todos los valores en col1 deben ser positivos.
  • col1<col2<col3: Todos los valores en col2 deben ser menores que los de col3 y mayores que los de col1.
  • col1//1000: Todos los valores en col1 deben ser divisibles por 1000.

• datasets_country: string. Especifica el país de origen de los datos. Se usa para generar variables sensibles y columnas de coordenadas.

• sensitive: dict. Especifica las variables sensibles y su tipo de sensibilidad. Formado por un diccionario donde las keys son el nombre de la variable sensible y el value es el tipo.

Los tipos soportados de variables sensibles son:

• address: Una dirección física o postal.

• city: Un nombre de ciudad.

• country: Un nombre de país.

• country_code: Un código de país 'alpha-2'.

• postcode: Un código postal.

• street_address: Una dirección compuesta por el número y el nombre.

• street_name: Un nombre de calle.

• license_plate: Una matrícula de coche.

• vin: Un número de identificación vehicular (VIN).

• aba: Un número de routing de la American Bankers Association (ABA).

• bank_country: Un código de país ISO 3166-1 alpha-2 del proveedor bancario.

• bban: Un Basic Bank Account Number (BBAN)

• iban: Un International Bank Account Number (IBAN).

• swift: Un código Society for Worldwide Interbank Financial Telecommunication (SWIFT) generado aleatoriamente de longitud variable.

• swift11: Un código SWIFT de 11 dígitos.

• swift8: Un código SWIFT de 8 dígitos.

• ean: Un European Article Number (EAN) de longitud variable.

• ean13: Un EAN de 13 dígitos.

• ean8: Un EAN de 8 dígitos.

• localized_ean: Un código de barras EAN localizado.

• localized_ean13: Un EAN localizado de 13 dígitos.

• localized_ean8: Un EAN localizado de 8 dígitos.

• company: Un nombre de empresa.

• credit_card_expire: Una fecha de expiración de tarjeta de crédito.

• credit_card_full: Una tarjeta de crédito completa, compuesta por el proveedor, nombre asociado, número de tarjeta, fecha de expiración y código CVC.

• credit_card_number: Un número de tarjeta de crédito.

• credit_card_provider: Un proveedor de tarjeta de crédito.

• credit_card_security_code: Un código de seguridad de tarjeta de crédito.

• coordinate: Una coordenada.

• latitude: Una latitud.

• longitude: Una longitud.

• company_email: Un email corporativo.

• domain_name: Un nombre de dominio de Internet.

• email: Una dirección de email.

• hostname: Un nombre de dominio asignado a una computadora host.

• ipv4: Una dirección IPv4 aleatoria o red con un CIDR válido.

• ipv4_private: Un IPv4 privado.

• ipv4_public: Un IPv4 público excluyendo bloques privados.

• ipv6: Una dirección IPv6 o red con un CIDR válido.

• mac_address: Una dirección MAC.

• url: Un Uniform Resource Locator (URL).

• passport_number: Un número de pasaporte.

• first_name: Un nombre.

• last_name: Un apellido.

• name: El nombre y apellido de una persona

• country_calling_code: Un código de llamada de país.

• msisdn: Un código MSISDN.

• phone_number: Un número de teléfono fijo o celular.

• ssn: Un número de seguridad social de EE.UU.

Las variables sensibles de cualquier otro tipo se reemplazarán por 0, 1, 2, ...

Variables y parámetros específicos

Transactional

Este algoritmo fue pensado para ser usado con datasets transaccionales, por lo tanto hay ciertas columnas esenciales para que funcione correctamente. Estas columnas son:

• Obligatorias:

  • txn_date (fecha de transacción) en date_columns.
  • amount (monto de transacción) en float_columns.
  • concept (descripción/concepto de la transacción o id de descripción) en categorical_columns.

• Opcionales:

  • user_id (User ID) en categorical_columns.
  • cat_id (Transaction Spending or Income Category ID) en categorical_columns.
  • balance (Balance antes o después de la transacción) en float_columns.

Nota: es importante que si el dataset no contiene una de estas columnas, algunas otras deben transformarse. Para hacer esto puedes transformar los nombres de estas columnas en el dataset o usar el parámetro columns_mapping. Por ejemplo, si quieres usar el dataset mostrado en el ejemplo anterior, los cambios recomendados son:

columns_mapping = {'cat_id':'BRANCH_ID',
                   'user_id':'SUPPLIER_ID',
                   'amount':'LTV',
                   'txn_date':'DISBURSAL_DATE'}

Timeseries

• time_step: string. Paso de tiempo de la timeserie. Valores disponibles: Time series / date functionality — pandas 2.0.1 documentation. Diferencia fija en tiempo entre las fechas de la timeserie. El valor por defecto es 'MS'. El valor 'MS' significa que hay un mes entre dos fechas consecutivas. IMPORTANTE: para cada time_step debe haber solo una observación (ejemplo: si es diario ('D') solo una observación/fila por día). El valor por defecto es 'MS'.

• series_length: int. Define la longitud de la timeserie basándose en el time_step. Representa el número de time_step contenidos en el dataset. Por ejemplo, si time_step='MS', entonces series_length debe ser un múltiplo de 12 (12, 24, 36, 48), asegúrate de que los datos correspondan a estos parámetros. No todas las series en los datos necesitan tener observaciones para años completos (por ejemplo: podrían tener observaciones para 11 meses de los 12 de ese año específico). El valor por defecto es 12.

• static_columns: list. Estas son las columnas que no cambian en el tiempo y son las mismas para todas las series del mismo user_id.

Relational

Este algoritmo tiene otros parámetros requeridos necesarios para su correcto funcionamiento. Para mejorar la calidad y eficiencia del algoritmo, el número de epochs se establece en 100 por defecto y no puede modificarse.

• datasets_country: string. Especifica el país de origen de los datos. Se usa para generar variables sensibles.

• datasets_config: dictionary. Define la configuración de cada tabla. El diccionario debe tener las siguientes keys equivalentes a la definición inicial:

  1. data_dir: string. Path al archivo del dataset.
  2. data_format: string. Formato de datos de entrada. Cuatro opciones: CSV, PARQUET, MTX o DATABASE.
  3. categorical_columns: array. Nombres de las columnas discretas en el dataset.
  4. date_columns: array. Nombres de las columnas de fecha en el dataset.
  5. integer_columns: array. Nombres de las columnas enteras en el dataset.
  6. boolean_columns: array. Nombres de las columnas booleanas en el dataset.
  7. float_columns: array. Nombres de las columnas float en el dataset.
  8. target: string. Nombre de la variable target para evaluar el utility y predictive power score, basado en la definición clásica de machine learning de target. Si es None, el algoritmo selecciona un target aleatoriamente de las variables disponibles. Si el target es numérico, se crearán bins del mismo y se pasará como categórico. Dedomena ajusta algoritmos de ML baseline para analizar el utility y predictive power de los datos, por lo tanto en muchos escenarios reales el target deseado no es posible de predecir con las variables dependientes disponibles.
  9. primary_key: str. Primary key de la tabla.
  10. foreign_key: dict. Especifica las foreign keys. Formado por un diccionario donde las keys son el nombre de la foreign key y el value es la tabla de la que viene.

Entrenar el synthesizer

Una vez que los parámetros están configurados para el algoritmo seleccionado de las opciones disponibles, es momento de entrenarlo y crear el synthesizer. Durante el tiempo de entrenamiento, los algoritmos de Dedomena aprenden patrones de datos, distribuciones estadísticas, correlaciones y dependencias temporales. En el proceso se realizan las verificaciones de privacidad, calidad y utility, y también se genera el QA report. Después de que la corrida se completa, el synthesizer resultante se empaqueta en un archivo zip encriptado que luego se subirá a los servidores de DEDOMENA.AI para generar copias sintéticas de los datos.

Subir el synthesizer y generar datos sintéticos

Cuando una corrida se completa y se crea el synthesizer, los usuarios necesitan subir el archivo encriptado a la plataforma de DEDOMENA.AI a través de la sección SYNTHESIZERS. A través del botón ADD SYNTHESIZER los usuarios pueden subir el archivo encriptado para registrar el synthesizer con la información asociada, métricas, reporte y generar datos artificiales. Trabaja con confianza, la calidad de los datos está asegurada.

Ejemplos de Código por Algoritmo

Ejemplo Generic

from nucleus import synthesizer

synthesizer(data_dir='dir/folder/train.parquet',
            data_format='PARQUET',
            token='1234',
            algorithm='generic',
            batch_size=256,
            epochs=150,
            synthesizer_name='my_synthesizer',
            synthesizer_description='kaggle dataset based synthesizer',
            impute=True,
            categorical_columns=['BRANCH_ID', 'MANUFACTURER_ID', 'EMPLOYMENT_TYPE', 'STATE_ID',
                                 'PERFORM_CNS_SCORE_DESCRIPTION', 'PRI_ACTIVE_ACCTS', 'PRI_OVERDUE_ACCTS',
                                 'NEW_ACCTS_IN_LAST_SIX_MONTHS'],
            integer_columns=['DISBURSED_AMOUNT', 'SUPPLIER_ID', 'CURRENT_PINCODE_ID', 'ASSET_COST',
                             'PERFORM_CNS_SCORE', 'PRIMARY_INSTAL_AMT', 'NO_OF_INQUIRIES',
                             'PRI_CURRENT_BALANCE', 'PRI_SANCTIONED_AMOUNT', 'PRI_DISBURSED_AMOUNT'],
            boolean_columns=['AADHAR_FLAG', 'PAN_FLAG', 'VOTERID_FLAG', 'DRIVING_FLAG', 'PASSPORT_FLAG'],
            float_columns=['LTV'],
            output_dir='results/',
            max_categories=None,
            min_freq_categories=None,
            cuda=True,
            amplify="quality")

Ejemplo Transactional

A continuación puedes encontrar un ejemplo del algoritmo transactional usando el mismo dataset de Kaggle: Vehicle Loan Default Prediction.

Ejemplo de ejecución:

Recuerda que necesitas hacer las transformaciones necesarias en el dataset para hacerlo compatible con el algoritmo, o usar el parámetro columns_mapping.

Por ejemplo, este debería ser el código para usar el dataset de Kaggle:

from nucleus import synthesizer

synthesizer(data_dir='dir/folder/train.parquet',
            data_format='PARQUET',
            token='1234',
            algorithm='transactional',
            batch_size=256,
            epochs=100,
            synthesizer_name='my_synthesizer',
            synthesizer_description='kaggle dataset based synthesizer',
            impute=True,
            categorical_columns=['BRANCH_ID', 'MANUFACTURER_ID', 'EMPLOYMENT_TYPE', 'STATE_ID',
                                 'PERFORM_CNS_SCORE_DESCRIPTION', 'PRI_ACTIVE_ACCTS', 'PRI_OVERDUE_ACCTS',
                                 'NEW_ACCTS_IN_LAST_SIX_MONTHS'],
            date_columns=['SUPPLIER_ID'],
            integer_columns=['SUPPLIER_ID', 'DISBURSED_AMOUNT', 'CURRENT_PINCODE_ID', 'ASSET_COST',
                             'PERFORM_CNS_SCORE', 'PRIMARY_INSTAL_AMT', 'NO_OF_INQUIRIES',
                             'PRI_CURRENT_BALANCE', 'PRI_SANCTIONED_AMOUNT', 'PRI_DISBURSED_AMOUNT'],
            boolean_columns=['AADHAR_FLAG', 'PAN_FLAG', 'VOTERID_FLAG', 'DRIVING_FLAG', 'PASSPORT_FLAG'],
            float_columns=['LTV'],
            output_dir='results/',
            max_categories=None,
            min_freq_categories=None,
            columns_mapping: {'cat_id': 'BRANCH_ID',
                              'user_id': 'SUPPLIER_ID',
                              'amount': 'LTV',
                              'txn_date': 'DISBURSAL_DATE'},
            cuda=True,
            amplify="default")

Ejemplo Time Series

Ejemplo de ejecución:

from nucleus import synthesizer

synthesizer(data_dir='dir/folder/train.parquet',
            data_format='PARQUET',
            token='1234',
            algorithm='timeseries',
            batch_size=1024,
            epochs=300,
            synthesizer_name='event_txns_synthesizer',
            synthesizer_description='event txns dataset based synthesizer',
            categorical_columns=['A', 'B'],
            date_columns=['txn_date'],
            integer_columns=[],
            boolean_columns=[],
            float_columns=['C'],
            static_columns=['B'],
            output_dir='results/',
            cuda=True,
            time_step='MS',
            series_length=12)

Ejemplo Relational

Ejemplo de un datasets_config:

datasets_config = {
                    'table1_name': {
                                    'data_dir': 'path/to/table1.csv',
                                    'data_format':'CSV',
                                    'algorithm': 'transactional',
                                    'columns_mapping':{
                                                        'user_id': 'col1',
                                                        'txn_date':'col3',
                                                        'concept':'col2',
                                                        'amount':'col6'
                                                        },
                                    'categorical_columns': ['col1', 'col2'],
                                    'date_columns': ['col3'],
                                    'integer_columns': ['col4'],
                                    'boolean_columns': ['col5'],
                                    'float_columns': ['col6'],
                                    'foreign_key': {'col7':'table2'},
                                    'primary_key':'col1',
                                    'sensitive': {'col2':'first_name'},
                                    'transform_descriptions':'level2',
                                    'target':'col2',
                                    'constraints':['col1<- />col2<->col3']
                                    },
                    'table2_name': {
                                    'data_dir': 'path/to/table2.parquet',
                                    'data_format':'PARQUET',
                                    'algorithm': 'generic',
                                    'categorical_columns': ['col1', 'col2'],
                                    'date_columns': ['col3'],
                                    'integer_columns': ['col4'],
                                    'boolean_columns': ['col5'],
                                    'float_columns': ['col6'],
                                    'foreign_key': {},
                                    'primary_key':'col1',
                                    'sensitive': {'col2':'name'},
                                    'target': None,
                                    'impute':False
                                    },
                  }

Ejemplo de ejecución:

from nucleus import synthesizer

synthesizer(token='1234',
            algorithm='relational',
            batch_size=256,
            datasets_config=datasets_config,
            synthesizer_name='my_synthesizer',
            synthesizer_description='kaggle dataset based synthesizer',
            output_dir='results/',
            datasets_country = 'Spain',
            cuda=True)

Re-entrenar un synthesizer

Nucleus Edge provee la capacidad de hacer fine-tuning de synthesizers pre-entrenados. Los parámetros de entrada para re-entrenar un modelo son los siguientes:

• data_dir: string. Path al archivo del dataset.

• data_format: enum. Formato de datos de entrada. Dos opciones: CSV o PARQUET.

• token: string. El token provisto por Dedomena para hacer operativo Nucleus Edge.

• epochs: int (se recomiendan valores entre 200-350). Número de epochs para re-entrenar.

• model_dir: string. Path al archivo .zip que contiene el modelo pre-entrenado.

• impute: bool. Siempre True.

• output_dir: string. Path donde se persistirá el archivo encriptado.

• max_categories: int. Número máximo de valores que debe tener una variable categórica. Si la variable tiene más categorías que el máximo, las menos comunes se asignarán a una nueva categoría "others".

• min_freq_categories: int. Número mínimo de valores que cualquier variable categórica debe tener. El resto de las categorías se agruparán en una sola categoría llamada "Others - DM".

• cuda: bool. Cuando es True usará GPU para el cómputo (tiene que estar disponible en el sistema), de lo contrario CPU. (Incluso si el modelo se entrenó en CPU, puede re-entrenarse en GPU.)

Un ejemplo de re-entrenamiento de un modelo es el siguiente:

from nucleus import retrain_synthesizer

retrain_synthesizer(data_dir='dir',
                    data_format='PARQUET',
                    token='1234',
                    epochs=10,
                    model_dir='dir/synthesizer.zip',
                    impute=True,
                    output_dir='results/',
                    max_categories=None,
                    min_freq_categories=None,
                    cuda=False)

El dataset de re-entrenamiento puede ser diferente del dataset usado en el primer entrenamiento, sin embargo debe mantener las mismas columnas (con el mismo nombre) usadas en el dataset de entrenamiento.

El output será un .zip protegido con el modelo re-entrenado.

Evaluar dos datasets desde Nucleus Edge

from nucleus import synthesizer_evaluations

privacy_score, quality_score, utility_score = synthesizer_evaluations(real_data='dir/',
                                                                      synthetic_data='dir/',
                                                                      categorical_columns=[],
                                                                      token = token,
                                                                      date_columns=[],
                                                                      integer_columns=[],
                                                                      boolean_columns=[],
                                                                      float_columns=[],
                                                                      output_dir='dir/'
                                                                     )

API

Dedomena provee una API REST para consumir datos sintéticos desde los synthesizers del usuario, habilitando una variedad de integraciones y powering casos de uso en tiempo real. Permite generar 5000 filas sintéticas por llamada. La API solo funciona con synthesizers entrenados con la última versión de Nucleus Edge disponible.

Funcionalidades avanzadas para datos sintéticos de mayor calidad

En esta sección, profundizaremos en algunas de las funcionalidades avanzadas que pueden usarse para generar datos sintéticos de mayor calidad. Nucleus permite crear datos sintéticos más precisos y efectivos gracias a las siguientes funcionalidades avanzadas:

• Gestión de outliers: Los outliers y el ruido son inevitables en datasets de la vida real y por lo tanto representan un problema de privacidad. El mecanismo de gestión de outliers es otra contribución importante del software de generación de datos sintéticos de DEDOMENA.AI, encontrando un balance en el trade-off entre privacidad (eliminar completamente los outliers) y calidad/utilidad de los datos (no perder información relevante, propiedades estadísticas) haciéndolos presentes en el dato sintético mientras se evitan problemas relacionados con la privacidad. Los synthesizers pueden producir outliers de forma y distribución controladas manteniendo el valor del dato real.

• Relaciones lineales / no lineales: Con todos nuestros algoritmos de sintetización podrás entregar un stream de datos sintéticos consistente, manteniendo tanto relaciones lineales como no lineales en los datos, lo que a su vez sienta las bases para análisis downstream más robustos y entrenamiento de modelos de IA. Además, los datos generados respetarán las precondiciones y dependencias entre datos maestro-referencia y mantendrán las secuencias de importación adecuadamente.

• Eficiencia computacional: El entrenamiento de modelos de deep learning que generan synthesizers es en general muy compute-intensive, sin embargo la arquitectura propietaria de Nucleus permite entrenarlos eficientemente en un tiempo razonable, optimizando recursos al limitar la interacción del usuario a la selección de unos pocos parámetros para crear los synthesizers, aceleración por GPU, fine-tuning de synthesizers, etc, dependiendo de la calidad deseada del dataset y su aplicación.

• Integridad referencial: Nuestra solución mantiene la integridad a través de variables y datasets como en los datos originales, siendo todas las referencias sintéticas válidas. Además, las primary y foreign keys sintéticas mantienen la estructura y comportamiento implícito de las entidades o usuarios reales representados en los diferentes feature spaces de todos los datasets. Nucleus es capaz de sintetizar dos o más tablas vinculadas, preservando las relaciones, patrones inter-tabla e información estadística entre los diferentes sets de datos. Dedomena AI provee una funcionalidad extra para permitir que datasets de diferentes países se mezclen con datos de referencia y maestro existentes, incluso cuando el proceso de sintetización se realiza en ubicaciones y entornos separados.

• Análisis bivariado y trivariado: Nucleus es capaz de replicar la estructura y distribuciones probabilísticas, así como las relaciones empíricas bivariadas y multivariadas de las variables de los datasets reales. Las distribuciones estadísticas se preservan con una consistencia de al menos 99%, mientras que las relaciones a nivel bivariado y trivariado se preservan con una consistencia de al menos 98% y 96% respectivamente.

• ‍Generación Condicional de Datos: [Próximamente] Los algoritmos de Nucleus soportan condicionamiento de modelo, lo que permite al synthesizer generar más registros que coincidan con cierta clase o label, en lugar de simplemente recrear la distribución con la que fue entrenado. Esta funcionalidad puede usarse para balancear distribuciones de clases en datasets para un machine learning más preciso o éticamente justo.