Suite

Un moyen efficace d'utiliser un fichier CSV pour définir une classe d'entités

Un moyen efficace d'utiliser un fichier CSV pour définir une classe d'entités


On m'a fourni une feuille de calcul Excel contenant les définitions de champs pour une classe d'entités. Il y avait plusieurs feuilles de calcul dans le fichier, chacune contenant des définitions de champ pour différentes classes d'entités. Après un peu de nettoyage, j'ai converti chaque feuille de calcul en un fichier CSV avec les colonnes suivantes :

Field_Name Field_Type Field_Length Field_Alias

Chacun des fichiers CSV avait entre 300 et 400 lignes, ce qui signifie qu'il y a autant de champs (je sais que c'est beaucoup de champs, mais ce n'est pas ma conception de schéma).

J'ai rassemblé un peu de code pour traiter les fichiers CSV et créer des champs pour les classes d'entités. Notez que les classes d'entités existent déjà dans une géodatabase et que les fichiers CSV portent le même nom que les classes d'entités.

Le code suivant fonctionne, mais il faut plus de 20 minutes pour créer 3 classes d'entités avec 300 à 400 champs chacune.

count = 0 pour csv_file dans CSVList : print csv_file print count with open(csv_file, 'rb') as csvfile : reader = csv.reader(csvfile, delimiter = ',') pour la ligne dans le lecteur : field_name = line[0] field_type = line[1] field_length = line[2] field_alias = line[3] arcpy.AddField_management(FCList[count],field_name, field_type, "","",field_length,field_alias) count+=1

Existe-t-il un moyen plus efficace de créer une classe d'entités à partir d'un fichier CSV avec des définitions de champ ? Ou, est-ce que arcpy.AddField_management est aussi bon que possible pour ce genre de chose ?


Étant donné que la géodatabase existe déjà, vous auriez pu utiliser le complément X-Ray pour ArcCatalog qui était Developper par Esri, en conjonction avec Vertex3. Il vous permet, entre autres, d'exporter le schéma vers une feuille de calcul, d'effectuer des modifications dans la feuille de calcul et de la réimporter dans une géodatabase.

X-Ray for ArcCatalog est disponible pour les versions 9.2 et 9.3 dans ArcScript et 10.x dans ArcGIS Online.


Vous pouvez convertir votre classe d'entités en une couche avec Créer une couche d'entités avant d'ajouter les champs. J'ai fait le test avec un tableau et 20 champs à ajouter : Sur mon ordinateur il faut normalement 2 min 04 sec pour créer le tableau et ajouter les champs. Cela ne prend que 31 secondes avec le Make Feature Layer ajouté. Cela vous prendrait encore environ 5 minutes, mais c'est facile à mettre en œuvre…


Un fichier de définition de table contient une définition de schéma de table externe et des métadonnées, telles que le format de données de la table et les propriétés associées. Lorsque vous créez un fichier de définition de table, vous pouvez utiliser la détection automatique de schéma pour définir le schéma d'une source de données externe, vous pouvez fournir le schéma en ligne (sur la ligne de commande) ou vous pouvez fournir un fichier JSON contenant la définition de schéma.

Les fichiers de définition de table sont utilisés avec l'outil de ligne de commande bq. Les propriétés d'un fichier de définition de table s'appliquent également à la création d'une ExternalDataConfiguration lorsque vous utilisez l'API REST. Vous n'utilisez pas de fichiers de définition de table lorsque vous créez une table externe à l'aide de Cloud Console.

Vous pouvez créer des fichiers de définition de table pour les sources de données externes suivantes :

  • Valeurs séparées par des virgules (CSV)
  • JSON délimité par une nouvelle ligne
  • fichiers Avro
  • Fichiers d'exportation de banque de données
  • fichiers ORC
  • Dossiers de parquet
  • Fichiers d'exportation Firestore
  • Valeurs séparées par des virgules (CSV)
  • JSON délimité par une nouvelle ligne
  • fichiers Avro
  • Feuilles Google

5 réponses 5

Bien en théorie, terrible en pratique

Par CSV Je vais supposer que vous voulez dire la convention telle que décrite dans la RFC 4180.

Bien que la correspondance des données CSV de base soit triviale :

Remarque : BTW, il est beaucoup plus efficace d'utiliser une fonction .split('/n').split('"') pour des données très simples et bien structurées comme celle-ci. Les expressions régulières fonctionnent comme un NDFSM (Non-Deterministic Finite State Machine) qui fait perdre beaucoup de temps à revenir en arrière une fois que vous commencez à ajouter des cas extrêmes comme des caractères d'échappement.

Par exemple, voici la chaîne de correspondance d'expression régulière la plus complète que j'ai trouvée :

Il gère raisonnablement les valeurs entre guillemets simples et doubles, mais pas les nouvelles lignes dans les valeurs, les guillemets échappés, etc.

Cela devient un cauchemar une fois que les cas limites courants sont introduits.

Le cas limite de nouvelle ligne en tant que valeur suffit à lui seul à casser 99,9999% des analyseurs syntaxiques basés sur RegEx trouvés dans la nature. La seule alternative « raisonnable » consiste à utiliser la correspondance RegEx pour la tokenisation des caractères de contrôle/non-contrôle de base (c'est-à-dire terminal vs non terminal) associée à une machine à états utilisée pour une analyse de niveau supérieur.

Source : Expérience autrement connue sous le nom de douleur et souffrance étendues.

Je suis l'auteur de jquery-CSV, le seul analyseur syntaxique CSV basé sur javascript et entièrement conforme aux RFC au monde. J'ai passé des mois à résoudre ce problème, à parler avec de nombreuses personnes intelligentes et à essayer une tonne d'implémentations différentes, y compris 3 réécritures complètes du moteur d'analyseur central.

tldr - Morale de l'histoire, PCRE à lui seul est nul pour analyser autre chose que les grammaires régulières les plus simples et les plus strictes (c'est-à-dire de type III). Bien que cela soit utile pour la tokenisation des chaînes terminales et non terminales.

Regex peut analyser n'importe quel langage régulier et ne peut pas analyser des choses fantaisistes comme les grammaires récursives. Mais CSV semble être assez régulier, donc analysable avec une regex.

Travaillons à partir de la définition : autorisées sont la séquence, les alternatives de forme de choix ( | ) et la répétition (étoile de Kleene, le * ).

  • Une valeur sans guillemets est régulière : [^,]* # tout caractère sauf virgule
  • Une valeur entre guillemets est régulière : "([^"]||")*" # séquence de tout sauf guillemet " ou guillemet échappé " ou échappement échappé
    • Certains formulaires peuvent inclure des guillemets d'échappement avec des guillemets, ce qui ajoute une variante ("")*" à l'expression ci-dessus.

    Je n'ai pas testé méticuleusement chacune de ces expressions et n'ai jamais défini de groupes de capture. J'ai également passé sous silence quelques détails techniques, comme les variantes de caractères qui peuvent être utilisées à la place de , , " , ou des séparateurs de ligne : ceux-ci ne cassent pas la régularité, vous obtenez juste plusieurs langues légèrement différentes.

    Si vous pouvez repérer un problème dans cette preuve, veuillez commenter ! :)

    Mais malgré cela, pratique l'analyse des fichiers CSV par des expressions régulières pures peut être problématique. Vous devez savoir laquelle des variantes est transmise à l'analyseur, et il n'y a pas de norme pour cela. Vous pouvez essayer plusieurs analyseurs sur chaque ligne jusqu'à ce que l'un d'eux réussisse, ou deviner en quelque sorte le format des commentaires. Mais cela peut nécessiter des moyens autres que les expressions régulières pour être efficace, voire pas du tout.

    Réponse simple - probablement pas.

    Le premier problème est l'absence de norme. Bien que l'on puisse décrire leur csv d'une manière strictement définie, on ne peut pas s'attendre à obtenir des fichiers csv strictement définis. "Soyez conservateur dans ce que vous faites, soyez libéral dans ce que vous acceptez des autres" -Jon Postal

    En supposant que l'on ait un standard qui soit acceptable, il y a la question des caractères d'échappement et si ceux-ci doivent être équilibrés.

    Une chaîne dans de nombreux formats csv est définie comme valeur de chaîne 1, valeur de chaîne 2 . Cependant, si cette chaîne contient une virgule, il s'agit désormais de "chaîne, valeur 1", valeur de chaîne 2 . S'il contient un guillemet, il devient "string, ""value 1""",string value 2 .

    A ce stade, je pense que c'est impossible. Le problème étant que vous devez déterminer combien de guillemets vous avez lus et si une virgule est à l'intérieur ou à l'extérieur du mode guillemets doubles de la valeur. L'équilibrage des parenthèses est un problème de regex impossible. Certains moteurs d'expressions régulières étendus (PCRE) peuvent le gérer, mais ce n'est donc pas une expression régulière.

    J'ai examiné les formats des caractères d'échappement et je n'en ai trouvé aucun nécessitant un comptage arbitraire - ce n'est donc probablement pas le problème.

    Cependant, il existe des problèmes de caractère d'échappement et de délimiteur d'enregistrement (pour commencer). http://www.csvreader.com/csv_format.php est une bonne lecture sur les différents formats dans la nature.

    • Les règles pour la chaîne entre guillemets (s'il s'agit d'une chaîne entre guillemets simples ou doubles) diffèrent.
      • "Ceci, est une valeur" vs "Ceci, est une valeur"
      • "Ce ""est une valeur""" vs "Ceci "est une valeur""
      • (brut intégré) "Ceci est une valeur" vs (échappé) "Ce est une valeur" vs (traduit) "Ce <0x1C>est une valeur"

      L'essentiel ici est qu'il est possible d'avoir une chaîne qui aura toujours plusieurs interprétations valides.

      La question connexe (pour les cas extrêmes) « est-il possible d'avoir une chaîne non valide qui est acceptée ? »

      Je doute encore fortement qu'il existe une expression régulière qui puisse correspondre à chaque CSV valide créé par une application et rejeter chaque CSV qui ne peut pas être analysé.


      3.3 Communiquer avec l'utilisateur

      Lorsque nous créons une fonction, nous voulons souvent que la fonction donne un retour efficace sur l'état actuel. Par exemple, y a-t-il des arguments manquants ou un calcul numérique a-t-il échoué. Il existe trois techniques principales pour communiquer avec l'utilisateur.

      Erreurs fatales : stop()

      Des erreurs fatales sont déclenchées en appelant le stop() , c'est-à-dire que l'exécution est terminée. Lorsque stop() est appelé, il n'y a aucun moyen pour une fonction de continuer. Par exemple, lorsque nous générons des nombres aléatoires à l'aide de rnorm(), le premier argument est la taille de l'échantillon, n . Si le nombre d'observations à renvoyer est inférieur à (1) , une erreur est générée. Lorsque nous devons signaler une erreur, nous devons le faire le plus rapidement possible, sinon c'est un gaspillage de ressources. Par conséquent, les premières lignes d'une fonction effectuent généralement une vérification des arguments.

      Supposons que nous appelions une fonction qui génère une erreur. Quoi alors ? Code efficace et robuste captures l'erreur et la gère de manière appropriée. Les erreurs peuvent être détectées à l'aide de try() et tryCatch() . Par exemple,

      Quand on inspecte les objets, la variable good ne contient que le chiffre 2

      Cependant, le mauvais objet est une chaîne de caractères avec la classe try-error et un attribut condition qui contient le message d'erreur

      Nous pouvons utiliser ces informations dans une instruction conditionnelle standard

      De plus amples détails sur la gestion des erreurs, ainsi que d'excellents conseils sur les techniques générales de débogage, sont fournis dans H. Wickham (2014a) .

      Avertissements : avertissement()

      Les avertissements sont générés à l'aide de la fonction warning(). Lorsqu'un avertissement est émis, il indique des problèmes potentiels. Par exemple, Mean(NULL) renvoie NA et déclenche également un avertissement.

      Lorsque nous rencontrons un avertissement dans notre code, il est important de résoudre le problème et de ne pas simplement ignorer le problème. Bien qu'ignorer les avertissements permet de gagner du temps à court terme, les avertissements peuvent souvent masquer des problèmes plus profonds qui se sont glissés dans notre code.

      Les avertissements peuvent être masqués à l'aide de suppressWarnings() .

      Sortie informative : message() et cat()

      Pour donner une sortie informative, utilisez la fonction message(). Par exemple, dans le loi de puissance package, la fonction message() est utilisée pour donner à l'utilisateur une estimation du temps d'exécution attendu. Fournir une estimation approximative de la durée de la fonction permet à l'utilisateur d'optimiser son temps. Semblable aux avertissements, les messages peuvent être supprimés avec suppressMessages() .

      Une autre fonction utilisée pour imprimer des messages est cat() . En général, cat() ne doit être utilisé que dans les méthodes print() / show(), par ex. regardez la définition de fonction de la méthode d'impression S3 pour les objets difftime, getS3method("print", "difftime") .

      Des exercices

      La fonction stop() a un appel d'argument. qui indique si l'appel de fonction doit faire partie du message d'erreur. Créez une fonction et expérimentez cette option.

      3.3.1 Retours invisibles

      La fonction invisible() vous permet de retourner une copie temporairement invisible d'un objet. Ceci est particulièrement utile pour les fonctions qui renvoient des valeurs qui peuvent être affectées, mais ne sont pas imprimées lorsqu'elles ne sont pas affectées. Par exemple, supposons que nous ayons une fonction qui trace les données et correspond à une ligne droite

      Lorsque la fonction est appelée, un graphique en nuage de points est tracé avec la ligne de meilleur ajustement, mais la sortie est invisible. Cependant, lorsque nous affectons la fonction à un objet, c'est-à-dire out = regression_plot(x, y), la variable out contient la sortie de l'appel lm().

      Un autre exemple est la fonction d'histogramme hist() . Typiquement, nous ne voulons rien afficher dans la console lorsque nous appelons la fonction

      Cependant, si nous affectons la sortie à un objet, out = hist(x) , l'objet out est en fait une liste contenant, entre autres, informations sur les points médians, les pauses et les comptages.


      "Date", "N° du compte", "Nom du client", "N° de la carte", "Nom du titulaire", "Statut", "Carte", "Carburant", "Nom de la pompe", "Prix", "Unités", " Sous-total","Taxes","Montant de la vente","Queue #"
      "01/10/2020 9:02",","","","XXXXXXXXXXXX11234","N1234RM ","Fermé","MasterCard","Jet A","Jet A","3.40000","180.00000 ","612.00","0","612.00",""

      Le message d'erreur que je reçois.

      Lecteur de fichiers TnvvCSV
      Format incorrect de la valeur du champ.
      N° d'enregistrement : 1 N° de champ : 1 (les deux commencent à partir de 1)

      о от стала роблема - айл csv 3 . 26 иллионов строк. росто читается он еликолепно и достаточно быстро
      в полях есть начения ак "Вася", так и "васяпетя"
      ставляя разделитель полей на '' надеялся что кавычки будут роигнорированы, но это не так.

      одскажите ак игнорировать авычки в полях?

      En supposant que vous n'ayez pas de valeurs de champ multiligne ni de valeurs avec des guillemets doubles à l'intérieur, vous pouvez ignorer les guillemets doubles en définissant UseFieldQuoting := false mais :
      1. Ils feront partie de la valeur :
      "Вася"
      "вася
      етя"
      2. Plus important encore, vous vous retrouvez très probablement dans une situation où le fichier se compose d'enregistrements avec un nombre de champs différent, ce qui rend le fichier invalide et le traitement s'arrête sur le premier enregistrement avec un nombre de champs différent.

      Je ne peux donc pas recommander cette solution.

      Mais, si j'ai bien compris, vous obtenez une situation où au moins certaines valeurs de champ sont composites. Pour être précis, ils sont eux-mêmes encodés dans un format de type CSV. Soit dit en passant, les guillemets doubles sont alors absolument nécessaires.

      Dans ce cas, il est impossible de décoder le fichier en un seul passage. Vous devez extraire les valeurs du fichier à l'aide de guillemets doubles et gérer certaines (ou toutes) d'entre elles comme encodées de type CSV à l'aide de TnvvCSVStringReader . Si ces valeurs de "second niveau" sont également composites, traitez-les à nouveau de la même manière et ainsi de suite.

      Excusez-moi de vous déranger à nouveau, mais un problème déroutant. Si j'appelle CSVRead.Free (et ne gère pas l'exception), j'obtiens un crash d'application - Erreur d'exécution 216. FWIW, ce code est dans une DLL Delphi. Si je parcoure le code une seule fois, le CSVRead.Free provoque une violation d'accès lors de l'exécution de l'instruction CSVRead.Free :

      Non géré, j'obtiens ceci suivi du message d'erreur d'exécution 216 :

      Il semble que ce soit après que j'ai apporté vos « ajustements » pour gérer le problème de FieldCount qui, en dehors de ce problème, fonctionne à merveille. Je devrais ajouter, si je n'ai pas l'instruction CSVRead.Free, j'obtiens également une erreur d'exécution 216. Des idées ?

      J'ai utilisé vos composants pour décoder une chaîne CSV et pour la plupart, cela fonctionne bien.

      Là où il y a un problème important (et peut-être que je le fais mal), mais dans le fichier CSV, la plupart des lignes ont 10 champs CEPENDANT une ligne au milieu de la chaîne CSV n'a que 7 champs. Votre composant s'interrompt simplement lorsqu'il détecte une ligne qui a un nombre de champs différent de celui spécifié initialement ou détecté automatiquement dans la première ligne.

      Dans un monde parfait, toutes les lignes auraient le même nombre de champs, mais ce n'est pas un monde parfait.

      Comment puis-je simplement traiter la ligne telle quelle ou l'ignorer (peut-être en notant le fait qu'il y avait un écart dans le nombre de champs.

      Si une erreur est détectée dans le nombre de champs, NE PAS ABANDONNER, définissez simplement une variable d'erreur (ou autre) et passez à la ligne suivante.

      Je sais que cela ralentirait les choses, mais pour moi, cela fonctionnerait. Avoir une propriété qui calcule le fieldcount PAS en utilisant la première ligne, mais pour chaque ligne :

      Donc, si cela est vrai, il ignore les paramètres FieldCount_AutoDetect et calcule le nombre de champs ligne par ligne.

      Comme vous le savez, ce sont toujours les cas extrêmes qui causent le chagrin.

      Merci pour une excellente unité, mais avec un problème pour moi.

      Merci pour une bonne question. Le problème réside dans le fait qu'en raison de la nature du format CSV, il est pratiquement impossible de trouver général algorithme de récupération d'erreur bien que le format CSV soit très "compact" et élégant.

      Voici quelques exemples pour illustrer l'ampleur d'un problème :
      - La source a des valeurs de champ multilignes. Erreur dans la valeur multiligne avant la fin de ligne « interne ». Si vous essayez de récupérer et de continuer, cette fin de ligne sera considérée comme une fin de record et tout se déchaîne avec un résultat difficile à imaginer.
      - Erreur qui conduit à la lecture de guillemets « non appariés » (plus de guillemets doubles dans la source). Ensuite, l'algorithme lira le reste de la source comme une valeur unique et ne détectera l'erreur qu'à la fin de la source.

      Le nombre de situations possibles semble incalculable. Pour faire face à un tel problème, il faut probablement développer une sorte d'intelligence artificielle (IA), ce qui, bien sûr, est intéressant mais peu pratique.

      Même dans les situations les plus simples, lorsque certains enregistrements ont apparemment un format absolument valide et un nombre insuffisant de champs, il n'est toujours pas clair comment interpréter ces enregistrements. Quels champs sont manquants : de début ou de fin ou ensemble mixte ? De toute évidence, ces enregistrements ne devraient pas être fiables et devraient probablement être supprimés. Mais probablement tout le fichier contenant ces enregistrements n'est pas fiable. Et je ne considère même pas la situation lorsque le nombre de champs est plus grand car cela complique encore plus la situation. En d'autres termes, jusqu'à présent, je ne vois aucune autre approche «efficace» pour traiter les erreurs CSV, à l'exception d'une intervention humaine «manuelle» pour corriger la source CSV.

      En fait, j'avais déjà prévu de mettre en œuvre tout ce que vous proposiez (en effet, je vis aussi dans le monde réel). J'ai juste besoin de trouver le temps de tout présenter dans un « paquet sain d'esprit ».

      Je devrais probablement ajouter à la prochaine version une option pour ignorer les enregistrements erronés, même si, en général, le résultat du "saut" ne peut pas être prédit. Il appartiendra à l'utilisateur de faire face aux conséquences de ce choix.

      La prise en charge de la longueur d'enregistrement variable (numéro de champ différent) est plus réaliste et plus logique, bien que l'on puisse se demander pourquoi le nombre de champs est différent : à cause d'une erreur ou « par conception » ? Quoi qu'il en soit, c'est une situation pratique relativement fréquente. Bien qu'il ne soit pas tout à fait correct de parler de « format CSV » ici. C'est juste une sorte de format délimité par des valeurs. Le format CSV consiste à présenter les données sous forme de tableau. Après tout, nous ne nous attendons pas à un numéro de champ variable dans les ensembles de données renvoyés par les bases de données relationnelles. La bonne approche pour les producteurs de données CSV consisterait à ajouter le nombre nécessaire de champs vides.

      Cela dit, je peux vous proposer quelques solutions de contournement rapides. Et ils sont "rapides" en effet puisque je n'ai pas eu beaucoup de temps pour le rendre "plus sympa".

      1. Pour une situation très particulière lorsque l'enregistrement a un format valide mais que le nombre de champs est inférieur (. ) à celui requis, vous pouvez essayer de modifier le code en lui demandant d'ignorer cet enregistrement. (Notez que dans une situation où le nombre de champs est excessif, la lecture sera toujours terminée). Pour y parvenir, la procédure DoEndOfLine doit être modifiée de la manière suivante :


      Quels sont les cinq types de segmentation du marché ?

      Les cinq types de segmentation du marché comprennent :

      • Segmentation comportementale
      • Segmentation psychographique
      • Segmentation démographique
      • Segmentation géographique
      • Segmentation Firmographique

      Regarder : Comment utiliser l'économie comportementale et narrative (webinaire)


      Algorithme d'optimisation

      Bien qu'il s'agisse de la partie la plus difficile sur le plan conceptuel de l'optimisation bayésienne, la création de l'algorithme d'optimisation dans Hyperopt se fait en une seule ligne. Pour utiliser l'estimateur Tree Parzen, le code est :

      C'est tout ce qu'on peut en dire! Hyperopt n'a que l'option TPE avec la recherche aléatoire, bien que la page GitHub indique que d'autres méthodes peuvent être à venir. Pendant l'optimisation, l'algorithme TPE construit le modèle de probabilité à partir des résultats passés et décide du prochain ensemble d'hyperparamètres à évaluer dans la fonction objectif en maximisant l'amélioration attendue.


      Prétraitement des données

      SpaCy exige que les données d'entraînement soient au format suivant :

      Nous devons donc convertir nos données au format .csv au format ci-dessus. (Il existe également d'autres formes de données d'entraînement que spaCy accepte. Reportez-vous au Documentation pour plus de détails.) Nous supprimons d'abord les colonnes Phrase # et POS car nous n'en avons pas besoin, puis convertissons le fichier .csv en fichier .tsv. Ensuite, nous devons exécuter le script ci-dessous pour obtenir les données d'entraînement au format .json.

      Maintenant, les données devraient ressembler à,

      L'étape suivante consiste à convertir les données ci-dessus au format requis par spaCy. Cela peut être fait en utilisant le script suivant-

      Nous avons maintenant les données prêtes pour l'entraînement ! Entraînons un modèle NER en ajoutant nos entités personnalisées.


      Il existe plusieurs façons d'améliorer les performances de votre modèle afin d'obtenir des prédictions plus précises.

      L'ajout de données d'entraînement contenant suffisamment d'échantillons pour chaque utilisateur et chaque identifiant de film peut aider à améliorer la qualité du modèle de recommandation.

      La validation croisée est une technique d'évaluation des modèles qui divise aléatoirement les données en sous-ensembles (au lieu d'extraire les données de test de l'ensemble de données comme vous l'avez fait dans ce didacticiel) et prend certains groupes comme données d'apprentissage et certains groupes comme données de test. Cette méthode surpasse la division train-test en termes de qualité du modèle.

      Caractéristiques

      Dans ce didacticiel, vous n'utilisez que les trois fonctionnalités ( identifiant d'utilisateur , identifiant de film et évaluation ) fournies par l'ensemble de données.

      Bien que ce soit un bon début, en réalité, vous souhaiterez peut-être ajouter d'autres attributs ou fonctionnalités (par exemple, l'âge, le sexe, la géolocalisation, etc.) s'ils sont inclus dans l'ensemble de données. L'ajout de fonctionnalités plus pertinentes peut aider à améliorer les performances de votre modèle de recommandation.

      Si vous ne savez pas quelles fonctionnalités pourraient être les plus pertinentes pour votre tâche d'apprentissage automatique, vous pouvez également utiliser le calcul de la contribution des fonctionnalités (FCC) et l'importance des fonctionnalités de permutation, que ML.NET fournit pour découvrir les fonctionnalités les plus influentes.

      Hyperparamètres d'algorithme

      Bien que ML.NET fournisse de bons algorithmes d'entraînement par défaut, vous pouvez affiner davantage les performances en modifiant les hyperparamètres de l'algorithme.

      Pour Matrix Factorization , vous pouvez expérimenter avec des hyperparamètres tels que NumberOfIterations et ApproximationRank pour voir si cela vous donne de meilleurs résultats.

      Par exemple, dans ce tutoriel, les options de l'algorithme sont :

      Autres algorithmes de recommandation

      L'algorithme de factorisation matricielle avec filtrage collaboratif n'est qu'une approche pour effectuer des recommandations de films. Dans de nombreux cas, vous n'avez peut-être pas les données de classement disponibles et n'avez que l'historique des films disponible auprès des utilisateurs. Dans d'autres cas, vous pouvez avoir plus que les données d'évaluation de l'utilisateur.

      Algorithme Scénario Goûter
      Factorisation matricielle à une classe Utilisez ceci lorsque vous n'avez que userId et movieId. Ce style de recommandation est basé sur le scénario de co-achat, ou sur des produits fréquemment achetés ensemble, ce qui signifie qu'il recommandera aux clients un ensemble de produits en fonction de leur propre historique de bons de commande. >Essayer
      Machines de factorisation sensibles au terrain Utilisez-le pour faire des recommandations lorsque vous avez plus de fonctionnalités au-delà de l'ID utilisateur, de l'ID produit et de l'évaluation (comme la description du produit ou le prix du produit). Cette méthode utilise également une approche de filtrage collaboratif. >Essayer

      Nouveau scénario utilisateur

      Un problème courant dans le filtrage collaboratif est le problème de démarrage à froid, c'est-à-dire lorsque vous avez un nouvel utilisateur sans données précédentes à partir desquelles tirer des inférences. Ce problème est souvent résolu en demandant aux nouveaux utilisateurs de créer un profil et, par exemple, de noter les films qu'ils ont vus dans le passé. Bien que cette méthode impose une certaine charge à l'utilisateur, elle fournit des données de départ pour les nouveaux utilisateurs sans historique de notation.


      Exécution de l'application

      Exécutez l'application Spring Boot. Une fois l'application démarrée, connectez-vous à la console H2 en utilisant le lien http://localhost:8080/h2-console/ . Ensuite, vous obtiendrez un écran de connexion comme ci-dessous.


      Une fois connecté, nous pourrons voir le tableau Tension et toutes les tables créées par Spring Batch. Dans ces tableaux, nous trouverons tous les détails sur l'exécution du travail tels que le nom du travail, le statut, l'identifiant, etc.



      Voir la vidéo: TUTO IDOCEO#2 Créer un fichier ExcelCSV classe