Comment générer un énorme graphique financier avec des schémas de blanchiment d'argent?

Il y a quelques années, mon équipe (conformité dans l'une des banques suisses) et moi avions une tâche intéressante à mettre en œuvre - nous avons dû générer un énorme graphique aléatoire des transactions financières entre les clients, les entreprises et les distributeurs automatiques de billets. De plus, nous voulions que ce graphique contienne des schémas de blanchiment d'argent et d'autres délits financiers ainsi qu'une description des nœuds tels que les noms, adresses, devises, etc. De toute évidence, toutes les données doivent être générées de manière aléatoire à partir de zéro tant que nous ne pouvons pas utiliser de données réelles pour des raisons évidentes.

Comme solution, nous avons écrit un générateur que j'aimerais partager avec vous. Cet article explique pourquoi nous en avions besoin et comment ce générateur fonctionne, mais si vous ne voulez pas lire et que vous voulez l'essayer par vous-même, voici le code: https://github.com/MGrin/transactions-graph- générateur . J'espère que notre expérience sera utile à chacun d'entre vous.

Pourquoi étions-nous intéressés par un tel générateur?

Notre équipe a décidé de parrainer le hackaton LauzHack . L'une des conditions pour les sponsors était de fournir une véritable tâche commerciale aux participants, et par hasard, en même temps, nous avions un projet intéressant lié à la découverte du blanchiment d'argent dans le graphique de la transaction. Bien sûr, nous avons décidé de confier la même tâche aux participants au hackaton.

Comme je l'ai dit plus tôt, nous ne pouvions pas utiliser de vraies données, nous devions donc les créer. Afin de rendre la tâche aussi proche que possible du monde réel, nous avons obtenu des statistiques à partir de nos données et essayé de créer des données générées pour suivre des distributions similaires. De plus, nous ne voulions pas avoir un petit graphique - nous travaillons quotidiennement avec des milliards de transactions entre des millions de nœuds, et nous voulions donner aux participants la possibilité d'essayer leurs idées à la même échelle.

Qu'avons-nous obtenu en conséquence?

Nous pourrions construire un générateur de graphes assez rapide, intéressant et configurable! Voyons cela plus en détail:

Types de nœuds

Participants de notre système financier généré:

• Client - un compte d'un client bancaire abstrait. Contient des champs comme le nom, l'adresse e-mail, l'âge, la profession, l'éducation, la nationalité et l'adresse.
• Société - une entité commerciale dans notre système financier. Contient des champs comme le type, le nom et le pays.
• ATM - un point de sortie pour l'argent de notre graphique financier vers l'extérieur où il ne peut plus être suivi. Contient des coordonnées GPS.
• Transaction - enregistrement du transfert d'argent entre 2 nœuds de graphique. Contient des pointeurs vers les nœuds source et cible, le montant, la devise et la date et l'heure d'exécution.

Pour générer ces données, nous avons utilisé Mimesis , une excellente bibliothèque pour la génération de fausses données.

Génération de graphes: entités de base

Le générateur commence par la création d'entités de base - clients, entreprises et distributeurs automatiques de billets. Le script prend en entrée un nombre souhaité de clients et, sur la base de ce nombre, calcule le nombre d'entreprises et de distributeurs automatiques de billets à générer. Nous avons déduit que le nombre d'entreprises est égal à 2,5% du nombre total de clients et le nombre de distributeurs automatiques de billets est égal à 0,05%. Ces paramètres sont assez moyennés et sont codés en dur à l'intérieur du générateur lui-même.

Toutes les informations générées sont enregistrées dans des fichiers .csv. L'écriture dans ces fichiers se fait par lots de k lignes, k étant un paramètre configurable. De plus, chaque type de nœud est généré en parallèle pour accélérer l'ensemble du processus.

Génération de graphe: arêtes entre entités

Après la création des entités de base, nous commençons à les connecter entre elles. À ce stade, nous ne générons pas encore de transactions, mais uniquement le fait que deux nœuds sont connectés. Nous l'avons fait de cette façon pour accélérer le processus et cela fonctionne comme suit: s'il y a un bord entre deux nœuds, il y aura un certain nombre de transactions séparées dans le temps. Aucun avantage - aucune transaction du tout.

La probabilité si et le bord entre deux nœuds et les types de bords possibles sont:

• Client -> Client, p = 0,4%
• Client -> Entreprise, p = 1%
• Client -> ATM, p = 3%
• Entreprise -> Client, p = 0,5%

Ces probabilités peuvent être configurées à l'aide des paramètres du générateur.

Tout comme les nœuds, tous les types de bords sont générés en parallèle et sont écrits dans des fichiers par lots.

Génération de graphiques: transactions

Ayant des nœuds et des bords ayant une distribution souhaitée, nous pouvons commencer la génération de transactions. Le processus est simple à mettre en œuvre mais est assez difficile à mettre en parallèle. De ce fait, à ce stade, seuls deux threads fonctionnent - un pour la génération de transactions de sourcing client, un autre - pour la génération de transactions de sourcing d'entreprise. Le nombre de transactions pour un bord est aléatoire et séparé aléatoirement dans le temps.

Comme ci-dessus, les transactions générées sont écrites dans des fichiers .csv par lots.

Génération de graphes: motifs

C'est là que les choses deviennent intéressantes. Nous avons défini trois modèles que nous voulions avoir dans notre graphique:

• Flux - une grande quantité d'argent est envoyée du nœud source à N nœuds, et eux l'un de ces N nœuds envoie de l'argent à un autre K nœuds, etc. jusqu'à ce que la dernière couche de ce réseau envoie tout l'argent reçu à un nœud cible.
• Circulaire - une grande somme d'argent passe par différents nœuds et revient au nœud source.
• Temps - une certaine quantité est transférée du nœud A au nœud B plusieurs fois, séparées par un temps pseudo-aléatoire.

Découvrons ces motifs un par un.

Débit

Nous commençons par sélectionner un certain nombre de couches du réseau. Dans notre réalisation, il s'agit d'un nombre aléatoire compris entre 2 et 6, et ces valeurs ne sont pas configurables. Ensuite, nous choisissons au hasard 2 nœuds - source et cible. De plus, le montant qui sera émis par un nœud source est généré aléatoirement comme 50000 * random () + 50000 * random ().

Chaque participant de ce réseau prend un paiement pour son service. Dans notre réalisation, le paiement total pour l'ensemble de l'utilisation du réseau ne dépassera pas 10% du montant de la source.

Toutes les transactions générées sont retardées dans le temps d'une couche à l'autre. Les délais sont aléatoires et ne dépassent pas 5 jours.

Circulaire

Est similaire au modèle Flow, sauf que les nœuds source et cible sont identiques et qu'il n'y a qu'un seul nœud par couche intermédiaire.

Le temps

Le modèle le plus simple. Une quantité aléatoire est envoyée du nœud A au nœud B plusieurs fois (nombre aléatoire entre 5 et 50, non configurable) avec des retards pseudo-aléatoires entre les transactions.

Randomisation des transactions finales

À ce stade, nous avons un certain nombre de fichiers .csv:

• 3 fichiers avec informations sur les nœuds (clients, entreprises, distributeurs automatiques de billets)
• 4 fichiers avec transactions: un pour les transactions habituelles et 3 pour les transactions à partir des modèles générés.

Il existe un autre script qui randomise toutes les transactions et les encapsule dans un fichier de transactions.

Que faire avec la sortie de ce générateur

À la fin de la journée, nous avons 4 beaux fichiers .csv avec des nœuds de graphique et des transactions. Nous pouvons importer ce graphique dans Neo4J ou le servir via l'API REST - fondamentalement, nous pouvons tout faire avec! La taille du graphique peut être aussi grande que vous le souhaitez (nous avons fini par générer un graphique avec 2 milliards de clients et cela a pris environ 8 heures sur mon MacBook 2014).

Nous avons beaucoup de retours positifs de la part des participants au hackaton ainsi que quelques très bonnes solutions de problème de détection de modèle dans les grands graphiques.

Merci pour votre temps, et voici le lien vers le générateur: https://github.com/MGrin/transactions-graph-generator