Suite

Est-il possible d'utiliser des couches mémoire dans les algorithmes de traitement QGIS ?

Est-il possible d'utiliser des couches mémoire dans les algorithmes de traitement QGIS ?


Je construis un plugin QGIS qui se connecte à une base de données MySQL sur le réseau local, puis ajoute un sous-ensemble de l'une des tables à une couche en mémoire ; le sous-ensemble est basé sur l'actualité des données (en ne prenant que l'observation la plus récente pour chaque emplacement où les mesures sont effectuées). Cette couche mémoire est créée avec succès.

Cependant, je souhaite ensuite exécuter certains algorithmes de géotraitement et j'ai du mal à utiliser la couche en mémoire dans l'un d'entre eux.

self.stationuri = "point?crs=epsg:4326&field=id:integer&field={}:double&index=yes".format(self.cb_field.currentText()) self.vlayer = QgsVectorLayer(self.stationuri,"scratch"," memory") sinon self.vlayer.isValid(): raise Exception("Impossible de créer la couche en mémoire") self.vlayer.startEditing() pour i,r dans enumerate(result): # Le résultat est ligne par- résultat de la ligne de la requête SQL # Ajouter des fonctionnalités… self.vlayer.commitChanges() self.vlayer.updateExtents() # Ajouter une couche à la carte QgsMapLayerRegistry.instance().addMapLayer(self.vlayer) # La couche est ajoutée avec succès à la carte avec toutes les fonctionnalités et la géométrie # CI-DESSOUS EST LÀ O IL S'ÉCROUTE essayez: processing.runandload("gdalogr:gridinvdist",self.vlayer,self.cb_field.currentText(),2,0,0,0,0,0,0,0,' Float32',Aucun) # Aucun = sortie en mémoire ; J'obtiens la même erreur si je spécifie un chemin de chaîne et un nom de fichier. sauf exception, e : augmenter e

Aucune exception n'est levée, mais aucune sortie n'est produite ou ajoutée à la table des matières, mais le journal suivant est créé danstraitement.log:

INFO|Lun 04 mai 2015 11:28:23|Sortie de la console d'exécution GDAL|/bin/sh : 1 : /tmp/processing/bbebe7599c83446d9c2b03a251879657/OUTPUT.tif : introuvable|/bin/sh : 1 : -zfield : introuvable ||ÉCHEC : La source de données source n'est pas spécifiée.|Utilisation : gdal_grid [--help-general] [--formats]| [-ot {Byte/Int16/UInt16/UInt32/Int32/Float32/Float64/| CInt16/CInt32/CFloat32/CFloat64}]| [-de format] [-co "NOM=VALEUR"]| [-zfield nom_champ] [-z_increase augmenter_valeur] [-z_multiply multiplier_valeur]| [-a_srs srs_def] [-spat xmin ymin xmax ymax]| [-clipsrc |WKT|source de données|spat_extent]| [-clipsrcsql sql_statement] [-clipsrclayer couche]| [-clipsrcoù expression]| [-l layername]* [-where expression] [-sql select_statement]| [-txe xmin xmax] [-tye ymin ymax] [-outsize xsize ysize]| [-a algorithme[:parameter1=value1]*] [-q]|  ||Algorithmes et paramètres disponibles avec leurs valeurs par défaut :| Distance inverse à une puissance (par défaut)| invdist:power=2.0:lissage=0.0:radius1=0.0:radius2=0.0:angle=0.0:max_points=0:min_points=0:nodata=0.0| Moyenne mobile| moyenne:radius1=0.0:radius2=0.0:angle=0.0:min_points=0:nodata=0.0| Voisin le plus proche| plus proche:radius1=0.0:radius2=0.0:angle=0.0:nodata=0.0| Diverses métriques de données| :radius1=0.0:radius2=0.0:angle=0.0:min_points=0:nodata=0.0| les métriques possibles sont :| minimum| maximum| gamme| compter| moyenne_distance| moyenne_distance_pts|

La partie importante semble êtreÉCHEC : la source de données source n'est pas spécifiée.pourtantself.vlayer.isValid() == Vrai, donc je ne vois pas ce qui ne va pas avec mon entrée. j'ai essayé de remplacerself.vlayeravec'mémoire:scratch'dans l'appel àtraitement.runandload, mais j'obtiens ensuite l'erreur suivante imprimée sur la console (mais non déclenchée):Erreur : valeur de paramètre incorrecte : mémoire : scratch.

J'obtiens le même problème lorsque je l'exécute via l'interface graphique QGIS et que j'utilise le menu déroulant pour sélectionner monrayurecouche qui se trouve dans la COT. Cela se produit si je spécifie le raster de sortie en mémoire ou si je spécifie un emplacement sur le disque.

Cette question semble similaire, mais leur solution consistait à ajouter la couche mémoire à la table des matières avant de l'utiliser. Je le fais déjà et pourtant l'erreur persiste.

Je pensais qu'il s'agissait d'un problème général avec les couches mémoire et les algorithmes de géotraitement QGIS, mais ce qui suit fonctionne sans problème :

processing.runandload("qgis:fixeddistancebuffer",self.vlayer, 500, 5, True, "output_buffer.shp")

Qu'est-ce que je fais mal? Pourquoi mon jeu de données source mémoire ne peut-il pas être "spécifié" dans certains algorithmes de traitement ?

EDIT : voici le code source degdalogr:gridinvdistsi c'est utile.


Il semble que les couches de mémoire ne puissent pas être utilisées comme entrée pour les scripts de traitement GDAL/OGR car Processing ne prépare pas correctement les données à utiliser avec ogr2ogr. C'est pourquoi, par exemple, l'outil tampon QGIS fonctionne mais l'outil tampon GDAL/OGR échoue :

Algorithme Buffer vecteurs commençant… Commande GDAL : cmd.exe /C ogr2ogr.exe "C:UsersanitaAppDataLocalTempprocessing70e5e0852cb9456ba2e3780f8386122e86d237c8f41443f58a230a230a8133172047RS6772meopoint SGID? -461d-aff6-6271ded02eea} point?crs=EPSG:4326&memoryid={6772bccd-f55d-461d-aff6-6271ded02eea} -dialect sqlite -sql "SELECT ST_Buffer( geometry , 1000 ),* FROM 'point?crs=EPSG:4326&memoryid ={6772bccd-f55d-461d-aff6-6271ded02eea}' " Sortie de la commande GDAL : ÉCHEC : impossible d'ouvrir la source de données 'point?crs=EPSG:4326' avec les pilotes suivants. -> JP2ECW -> OCI -> SOSI…

Le traitement devrait en quelque sorte préparer les données (les enregistrer dans un fichier), puis les transmettre à l'outil GDAL/OGR.

J'ai ouvert un ticket : impossible d'utiliser les couches mémoire avec les outils OGR


C'est la bonne méthode, comme expliqué dans la documentation http://docs.qgis.org/2.14/es/docs/user_manual/processing/console.html

le prochain code fonctionne avec en mémoire tous sauf le dernier qu'il est chargé

MDT=chemin/mdt.tif drain=processing.runalg("grass:r.drain",MDT,"",(pun),False,False,False,"%f,%f,%f,%f"% (xmin, xmax, ymin, ymax),0,-1,0.00100,Aucun) vect=processing.runalg("grass:r.to.vect",drain['output'],0,False,"%f, %f,%f,%f"% (xmin, xmax, ymin, ymax),0,Aucun) bu=processing.runalg("qgis:fixeddistancebuffer",vect['output'],Metros_afecta,1,False,Aucun ) buf=bu['OUTPUT'] bufe= QgsVectorLayer(buf,"area", "ogr") #le dernier chargement de la couche QgsMapLayerRegistry.instance().addMapLayers([bufe])

le processing.runalg renvoie un dictionnaire dans ce cas bu['OUTPUT'] LA SORTIE EST LA CLÉ, et la valeur est un chemin temporaire, vous pouvez voir la clé avec processeing.alghelp("traitement de nom") comme traitement,alghelp("herbe :r.drain")

revenir

processing.alghelp("grass:r.drain") ALGORITHME : r.drain - Trace un flux à travers un modèle d'altitude sur une carte raster. saisir  coordonner  vecteur_points  -c  -une  -n  GRASS_REGION_PARAMETER  GRASS_REGION_CELLSIZE_PARAMETER  GRASS_SNAP_TOLERANCE_PARAMETER  GRASS_MIN_AREA_PARAMETER  production 

dans ce cas, la clé est production , attention avec majuscule vous devez écrire en majuscule ou sans majuscule, dans ce cas pas majuscule


Et que diriez-vous de regarder GDAL Virtual File Systems (http://www.gdal.org/gdal_virtual_file_systems.html)

Il y avsimempréfixe pour les chemins de type fichier en mémoire…


Pourquoi crypter les données en mémoire ?

J'ai vu que KeePass ne crypte pas seulement son fichier de base de données de mots de passe, il peut également crypter les mots de passe qu'il détient en mémoire. C'est juste un exemple. Je pense à un nouveau projet traitant des données sensibles / personnelles et maintenant je me demande si je devrais également crypter les données conservées en mémoire. Ce projet serait mis en œuvre avec Java SE et une application Android supplémentaire. Il n'y aura pas de données stockées dans le cloud ou sur un serveur dans ce cas particulier. Les données d'Android seront importées par l'application Java SE Desktop via une connexion par câble.

Mais pourquoi est-ce vraiment nécessaire ? Les systèmes d'exploitation modernes ne fonctionnent-ils pas avec la gestion de la mémoire virtuelle, de sorte qu'il n'est pas possible pour les processus en espace utilisateur / en mode utilisateur d'accéder à la mémoire d'autres processus ?

Est-ce juste une autre ligne de défense s'il existe une vulnérabilité du système d'exploitation rendant possible l'accès à la mémoire étrangère ? Dans ce cas, je pense qu'il serait beaucoup plus facile de voler le fichier de données et d'utiliser un enregistreur de frappe pour récupérer le mot de passe saisi par l'utilisateur au lieu de voler les données via un accès mémoire.


J'ai enseigné le C++ à des étudiants de premier cycle pendant environ deux ans et j'ai couvert la récursivité. D'après mon expérience, votre question et vos sentiments sont très commun. À l'extrême, certains étudiants considèrent la récursivité comme difficile à comprendre tandis que d'autres veulent l'utiliser pour à peu près tout.

Je pense que Dave le résume bien : utilisez-le là où c'est approprié. C'est-à-dire, utilisez-le quand cela vous semble naturel. Lorsque vous faites face à un problème où il s'intègre bien, vous le reconnaîtrez très probablement : il semblera que vous ne pouvez même pas trouver une solution itérative. De plus, la clarté est un aspect important de la programmation. D'autres personnes (et vous aussi !) devraient être capables de lire et de comprendre le code que vous produisez. Je pense qu'il est sûr de dire que les boucles itératives sont plus faciles à comprendre à première vue que la récursivité.

Je ne sais pas si vous connaissez bien la programmation ou l'informatique en général, mais je pense fortement que cela n'a pas de sens de parler de fonctions virtuelles, d'héritage ou de concepts avancés ici. J'ai souvent commencé par l'exemple classique du calcul des nombres de Fibonacci. Cela s'intègre bien ici, puisque les nombres de Fibonacci sont définis de manière récursive. Ceci est facile à comprendre et ne nécessite pas tout caractéristiques fantaisistes de la langue. Une fois que les étudiants ont acquis une compréhension de base de la récursivité, nous avons examiné à nouveau quelques fonctions simples que nous avons construites précédemment. Voici un exemple :

Une chaîne contient-elle un caractère $x$ ?

Voici comment nous procédions auparavant : itérer la chaîne et voir si un index contient $x$.

La question est alors, pouvez on le fait récursivement ? Bien sûr que nous pouvons, voici une façon:

La prochaine question naturelle est alors, devrions-nous le faire comme ça? Probablement pas. Pourquoi? C'est plus difficile à comprendre et c'est plus difficile à imaginer. Par conséquent, il est également plus sujet aux erreurs.

Les solutions à certains problèmes sont plus naturellement exprimées en utilisant la récursivité.

Par exemple, supposons que vous ayez une structure de données arborescente avec deux types de nœuds : les feuilles, qui stockent une valeur entière et les branches, qui ont un sous-arbre gauche et droit dans leurs champs. Supposons que les feuilles soient ordonnées, de sorte que la valeur la plus basse se trouve dans la feuille la plus à gauche.

Supposons que la tâche consiste à imprimer les valeurs de l'arbre dans l'ordre. Un algorithme récursif pour faire cela est assez naturel :

Écrire du code équivalent sans récursivité serait beaucoup plus difficile. Essayez-le !

Plus généralement, la récursivité fonctionne bien pour les algorithmes sur des structures de données récursives comme les arbres, ou pour des problèmes qui peuvent naturellement être divisés en sous-problèmes. Découvrez, par exemple, les algorithmes de division et de conquête.

Si vous voulez vraiment voir la récursivité dans son environnement le plus naturel, alors vous devriez regarder un langage de programmation fonctionnel comme Haskell. Dans un tel langage, il n'y a pas de construction en boucle, donc tout est exprimé en utilisant la récursivité (ou des fonctions d'ordre supérieur, mais c'est une autre histoire, à connaître aussi).

Notez également que les langages de programmation fonctionnels effectuent une récursivité de queue optimisée. Cela signifie qu'ils ne créent pas de cadre de pile à moins qu'ils n'en aient pas besoin --- essentiellement, la récursivité peut être convertie en boucle. D'un point de vue pratique, vous pouvez écrire du code de manière naturelle, mais obtenir les performances d'un code itératif. Pour mémoire, il semble que les compilateurs C++ optimisent également les appels de queue, il n'y a donc pas de surcharge supplémentaire liée à l'utilisation de la récursivité en C++.

De quelqu'un qui vit pratiquement en récursion je vais essayer de faire la lumière sur le sujet.

Lors de la première introduction à la récursivité, vous apprenez qu'il s'agit d'une fonction qui s'appelle elle-même et qui est essentiellement démontrée avec des algorithmes tels que la traversée d'arbre. Plus tard, vous constaterez qu'il est beaucoup utilisé dans la programmation fonctionnelle pour des langages tels que LISP et F#. Avec le F# que j'écris, la plupart de ce que j'écris est récursif et pattern matching.

Si vous en apprenez plus sur la programmation fonctionnelle telle que F#, vous apprendrez que les listes F# sont implémentées sous forme de listes à chaînage simple, ce qui signifie que les opérations qui accèdent uniquement à la tête de la liste sont O(1) et l'accès aux éléments est O(n). Une fois que vous avez appris cela, vous avez tendance à parcourir les données sous forme de liste, en construisant une nouvelle liste dans l'ordre inverse, puis en inversant la liste avant de revenir de la fonction, ce qui est très efficace.

Maintenant, si vous commencez à y penser, vous vous rendez vite compte que les fonctions récursives pousseront un cadre de pile à chaque fois qu'un appel de fonction est effectué et peuvent provoquer un débordement de pile. Cependant, si vous construisez votre fonction récursive afin qu'elle puisse effectuer un appel de queue et que le compilateur prenne en charge la possibilité d'optimiser le code pour l'appel de queue. c'est-à-dire .NET OpCodes.Tailcall Field, vous ne provoquerez pas de débordement de pile. À ce stade, vous commencez à écrire toute boucle en tant que fonction récursive et toute décision en tant que correspondance avec les jours de if et while sont désormais de l'histoire ancienne.

Une fois que vous êtes passé à l'IA en utilisant le retour en arrière dans des langages tels que PROLOG, tout est récursif. Bien que cela nécessite de penser d'une manière assez différente du code impératif, si PROLOG est le bon outil pour le problème, il vous libère du fardeau d'avoir à écrire de nombreuses lignes de code et peut réduire considérablement le nombre d'erreurs. Voir : client Amzi eoTek

Pour revenir à votre question de savoir quand utiliser la récursivité, une façon dont je regarde la programmation est avec le matériel à une extrémité et les concepts abstraits à l'autre extrémité. Plus le problème est proche du matériel, plus je pense dans les langages impératifs avec if et while , plus le problème est abstrait, plus je pense dans les langages de haut niveau avec récursivité. Cependant, si vous commencez à écrire du code système de bas niveau et que vous voulez vérifier qu'il est valide, vous trouvez alors des solutions comme les prouveurs de théorème qui s'avèrent utiles, qui reposent fortement sur la récursivité.

Si vous regardez Jane Street, vous verrez qu'ils utilisent le langage fonctionnel OCaml. Bien que je n'aie rien vu de leur code, en lisant ce qu'ils mentionnent à propos de leur code, ils pensent de manière récursive.

Puisque vous recherchez une liste d'utilisations, je vais vous donner une idée de base de ce qu'il faut rechercher dans le code et une liste d'utilisations de base qui sont principalement basées sur le concept de catamorphisme qui va au-delà des bases.

Pour C++ : si vous définissez une structure ou une classe qui a un pointeur vers la même structure ou classe, la récursivité doit être prise en compte pour les méthodes de parcours qui utilisent les pointeurs.

Le cas simple est une liste chaînée à sens unique. Vous traiteriez la liste en commençant par la tête ou la queue, puis parcourriez la liste de manière récursive à l'aide des pointeurs.

Un arbre est un autre cas où la récursivité est souvent utilisée à tel point que si vous voyez une traversée d'arbre sans récursivité, vous devriez commencer à demander pourquoi ? Ce n'est pas faux, mais quelque chose qui devrait être noté dans les commentaires.


Tant la quantité de données et le nombre d'arbres de votre forêt occupera de la mémoire.

Pour la quantité de données dont vous disposez, il est évident que cela prend du stockage - ce sont des données, donc plus vous en avez, plus elles prennent d'espace en mémoire. Si votre ensemble de données est trop volumineux, vous ne pourrez peut-être même pas tout lire en mémoire - il devra peut-être rester sur le disque pour la formation (je ne pense pas que scikit le supporte).

Pour le nombre d'arbres, chaque arbre cultivé est entraîné sur un sous-ensemble de caractéristiques aléatoires (afin que la forêt puisse éviter la variance et éviter que tous les arbres poussent de la même manière). Une fois que la forêt est formée, l'objet modèle aura des informations sur chaque arbre individuel - c'est le chemin de décision, les nœuds divisés, les seuils, etc. Ce sont des informations, et plus vous avez d'informations, plus il aura besoin de stockage. Donc plus d'arbres = plus d'informations = plus d'utilisation de la mémoire.

Il existe d'autres facteurs qui déterminent la quantité de mémoire que l'objet modèle (la forêt entraînée) utilisera, par exemple, max_depth qui définit le nombre maximal de couches/niveaux qu'un arbre peut atteindre. S'il est grand, les arbres peuvent pousser plus profondément et donc l'objet modèle sera plus grand et nécessitera donc plus de stockage. Cela ne devrait pas être trop grand cependant, pour éviter le surapprentissage.


1 réponse 1

Non, ce n'est pas sûr du tout. Une phrase secrète produirait une clé déterministe, mais cela rendrait cette clé vulnérable aux attaques par force brute et par dictionnaire. De plus, Fernet.generate_key() utilise un CSPRNG ( os.urandom() ) qui a une source aléatoire spécifique au système d'exploitation et il n'accepte pas de graine.

Il est possible de créer des clés déterministes mais fortes, en utilisant un KDF basé sur un mot de passe. La bibliothèque hashlib intégrée de Python offre deux de ces fonctions : pbkdf2_hmac() et scrypt() . Les deux KDF introduisent un facteur de travail (une bonne quantité de ressources CPU doit être dépensée pour produire une clé) qui rend pratiquement impossible les attaques par force brute/dictionnaire. Je recommande scrypt car il coûte des ressources CPU, mémoire et parallélisation, tandis que PBKDF2 ne consomme que des ressources CPU.

Création d'une clé compatible Fernet avec scrypt :

Le sel doit être long et aléatoire bien que ce ne soit pas un secret, il doit être unique pour chaque mot de passe. Les paramètres n, r et p déterminent le facteur de travail (n=coût CPU/mémoire, r=taille de bloc, p=parallélisation). Ces valeurs peuvent être augmentées en fonction du système d'exploitation - le processus de dérivation de clé devrait prendre environ 100 ms. Seul le mot de passe est une valeur secrète, les valeurs salt et n, r, p peuvent être stockées ou transmises avec la clé.


Je suppose que par C1 , C2 , etc., vous voulez dire des couches convolutives, et par P1 , P2 vous voulez dire des couches de mise en commun, et FC signifie des couches entièrement connectées.

Nous pouvons calculer la mémoire requise pour une passe avant comme ceci :

Si vous travaillez avec des valeurs float32, alors en suivant le lien fourni ci-dessus par @Alexandru Burlacu vous avez :

Entrée : 50x50x3 = 7 500 = 7,5K

P2 : 12x12x64 = 9,216 = 9,2K <- C'est un problème (et mon approximation est une supposition très vague ici). Au lieu de travailler avec 50, 25, '12,5', il serait plus logique de travailler avec des multiples de 32. J'ai entendu dire que travailler avec des multiples de 32 est également plus efficace du point de vue de la mémoire. La raison pour laquelle c'est une mauvaise idée est que la mise en commun 2x2 ne divise pas correctement l'espace, pour autant que je sache. N'hésitez pas à me corriger si je me trompe.

Sortie : 1 x 10 = 10 = 0,01K (presque rien)

Mémoire totale : 7,5 Ko + 80 Ko + 20 Ko + 40 Ko + 0,5 Ko = 157,2 Ko * 4 octets = 628,8 Ko

Si vous travaillez avec une taille de mini-lot de 64, vous en lisez 64 en mémoire à la fois et effectuez les opérations ensemble, en augmentant le tout comme ceci :

Entrée : 64x50x50x3 = 480 000 = 480K = 0,48M

C1 : 64x50x50x32 = 5 120 000 = 5,12 M

P1 : 64x25x25x32 = 1 280 000 = 1,28M

C2 : 64x25x25x64 = 2 560 000 = 2,56M

P2 : 64x12x12x64 = 589 824 = 590K = 0,59M

FC : 64x500 = 32 000 = 32K = 0,032M

Sortie : 1x10x64 = 640 = 0.64K = 0.00064M (on s'en fiche, c'est minuscule)

Mémoire totale : 10M x 4 octets

40 Mo (je dis approximatif car le site web dit aussi une valeur approximative)

EDIT : J'ai mal lu le site, désolé.

Selon le site Web, un passage en arrière nécessite environ le triple, en raison de la nécessité de stocker :

les activations et gradients associés pour chaque neurone - ceux-ci sont de taille égale

les gradients des poids (paramètres) qui sont de la même taille que les paramètres


Introduction

Les changements climatiques, l'érosion environnementale, les catastrophes naturelles et l'augmentation des charges de trafic peuvent continuellement modifier le comportement et même provoquer la détérioration des ponts dans leur service à long terme [1]. L'application de BHM a été reconnue comme un outil attrayant pour améliorer la santé et la sécurité des ponts et fournir une alerte précoce sur les dommages à la structure [2,3,4]. Un système BHM typique fournit généralement diverses informations efficaces en temps réel telles que la température, le vent, les fissures, la déflexion et les contraintes. Nous pouvons utiliser ces informations pour évaluer l'état de santé du pont selon la méthode de diagnostic correspondante. Ainsi, la surveillance de la santé des ponts et l'évaluation de la sécurité sont des exigences inévitables pour le développement durable de l'ingénierie des ponts.

On sait que l'efficacité de détection des capteurs installés dans la construction du pont se détériore progressivement au cours de leur fonctionnement à long terme ce qui affecte la fiabilité des données de surveillance. De plus, les conditions environnementales sévères ont un impact sérieux sur la qualité des données collectées [2]. De plus, les types de données collectées sont différents et leur quantité est énorme. Par conséquent, la difficulté pour la recherche et l'application actuelles du système de surveillance de la santé des ponts n'est souvent pas de collecter les données de surveillance, mais de savoir comment extraire des informations utiles des données massives accumulées au fil du temps [5]. Cependant, la plupart des systèmes de gestion des ponts utilisent actuellement les données collectées à partir des capteurs sans analyse, ce qui affectera grandement la qualité des données et conduira la technologie d'identification des dommages à la structure du pont et de diagnostic des défauts à tomber dans un dilemme de « catastrophe des données ». Le but de cet article est d'utiliser des méthodes basées sur l'exploration de données pour surmonter les problèmes de subjectivité, de complexité de calcul élevée, de faible sensibilité et de technologie compliquée dans l'analyse traditionnelle.

Grâce au travail ininterrompu du système d'acquisition de données de surveillance du pont, une grande quantité de données sont transmises et stockées dans la base de données chaque jour. Par conséquent, les données accumulées dans la base de données peuvent être considérées comme massives pendant toute la période de fonctionnement du pont. La technologie traditionnelle des bases de données a montré sa faiblesse face à une telle quantité de stockage et de traitement de données. L'émergence de technologies telles que Hadoop offre une excellente solution au traitement massif de données.

Le traitement des données est un élément central du système de surveillance de la santé des ponts. Des données de haute qualité sont la base pour évaluer avec précision l'état de santé des ponts. Avec l'augmentation de l'échelle des données de surveillance des ponts, la technologie de base de données traditionnelle s'est progressivement affaiblie dans le stockage et le traitement des données. Afin de relever les défis posés par la croissance des données dans le système de surveillance des ponts, la fonction de surveillance et de prédiction des données des ponts combinée à Hadoop a une signification théorique et une valeur pratique. Dans ce travail, nous avons construit un cluster Hadoop à trois nœuds et testé l'algorithme proposé dans un environnement distribué.

Dans cet article, nous nous concentrons sur le traitement des données de surveillance ainsi que sur l'obtention de données structurées. Et puis, sur la base de la théorie des clusters de l'exploration de données, nous utilisons le réseau de neurones de Kohonen pour regrouper les données structurées et expliquer le point en clusters. Nous avons également établi un modèle de réseau LSTM pour prédire la déflexion qui peut refléter la santé de la structure du pont en analysant les données de surveillance historiques. Ces deux méthodes peuvent toutes deux être utilisées pour évaluer l'état de santé des ponts dans une certaine mesure. Le premier peut obtenir le modèle de classification des données collectées dans des conditions de fonctionnement normales, puis fournir une alerte précoce correspondante grâce à l'analyse des valeurs aberrantes générées lorsque de nouvelles données ont été entrées dans le réseau.

Ce dernier peut prédire la valeur d'un attribut spécifique, puis nous pouvons obtenir l'état de santé en comparant la valeur prédite avec sa valeur limitée en fonctionnement normal. En bref, le réseau neuronal de Kohonen peut faire une évaluation générale de la structure globale des ponts, et le réseau neuronal LSTM peut prédire la valeur d'un paramètre de pont spécifique. Ces deux approches ont leur propre accent, mais toutes deux peuvent également évaluer l'état de santé des ponts. Les principaux apports et travaux sont les suivants :

Nous prétraitons les données collectées par les capteurs du système de surveillance de la santé du pont. Tout d'abord, nous remplissons les valeurs manquantes en analysant la plage de valeurs des données ainsi que les données historiques et les données empiriques. Deuxièmement, nous analysons la cause des données anormales et les réparons. Enfin, nous fusionnons les données les plus proches en temps d'acquisition puis standardisons chaque enregistrement.

Nous utilisons le réseau neuronal de Kohonen pour regrouper de manière auto-adaptative les données structurées traitées et obtenir le modèle de classification des données collectées dans des conditions de fonctionnement normales. Ensuite, nous pouvons analyser les valeurs aberrantes générées lorsque de nouvelles données ont été entrées dans le réseau et fournir une alerte précoce correspondante en fonction des résultats.

Nous utilisons le modèle de prédiction de séries chronologiques établi par le réseau de neurones LSTM pour prédire la valeur de déviation. Et puis nous pouvons obtenir l'état de santé en comparant la valeur prédite avec sa valeur limite en fonctionnement normal.


5 réponses 5

De grands nombres sont utilisés dans les défis de code car ils sont difficiles à gérer, c'est la même raison pour laquelle ils sont utilisés pour le cryptage. Il existe des classes BigInt pour la plupart des langues qui peuvent les rendre plus faciles à gérer. La plupart des problèmes de code peuvent être résolus tout en traitant au minimum de grands nombres. Cependant, il existe des solutions intelligentes qui trouvent des moyens d'éviter d'avoir à travailler avec de grands nombres jusqu'à ce que cela soit absolument nécessaire.

Bien que la solution exacte dépende du problème réel, vous pouvez essayer différentes approches avant de simplement calculer en force brute à l'aide d'un arbitraire ou alors plusieurs bibliothèque de mathématiques de précision (BigInt, GMP, MPFR, ARPREC, etc.).

Tout d'abord, utilisez quelques mathématiques. Les expressions peuvent-elles être simplifiées ? Vous avez dit que la source de ces tâches implique des énigmes, donc je serais très enclin à regarder cette approche pour une solution, car cela peut être un facteur dans les énigmes' aha moment. Les équations factorielles, telles que les probabilités binomiales, peuvent généralement être simplifiées ou calculées (indirectement) en utilisant des techniques mathématiques plutôt que la force brute.

La factorisation des nombres et l'annulation des facteurs communs seraient l'une des premières choses que j'essaierais, à la main si besoin est. Une calculatrice à précision multiple peut être utile.

Recadrerait la question ou ses valeurs dans une base différente (par exemple, binaire, hexadécimale) ou une échelle de différence (par exemple, base logarithmique 2, 10 ou e -- Naturel) rendent les valeurs plus faciles à traiter ? Un exemple d'échelle logarithmique est le décibel, utilisé pour les niveaux RF et audio.

L'utilisation de techniques moins enseignées de nos jours, mais bien connues des programmeurs, ingénieurs, mathématiciens familiarisés avec la règle à calcul peut parfois être utile.

Selon la question, faire d'abord une approximation peut parfois vous conduire vers la bonne réponse en empêchant les minuties de vous distraire d'attaquer le problème de manière créative.

Pour votre exemple, calculez une équation apparentée (approximative) mais simplifiée.

ce qui est très proche de la réponse correcte ou exacte

Une autre "astuce" consiste à utiliser modulo ( mod , % , modulo , a mod n ) qui est l'un de mes moyens préférés pour réduire les nombres, donc si vous connaissez quelques notions d'algèbre abstraite de base, vous pouvez parfois travailler avec l'arithmétique modulaire.

C'est un guide improvisé et très approximatif sur la façon dont j'aborderais une équation "puzzle" ou un problème de programmation qui implique de grands nombres.


5 réponses 5

Il m'a dit qu'il n'y a que deux cryptages qu'il connaît qui ne peuvent pas être brisés, et AES n'en fait pas partie

Cela me dit que vous avez posé la mauvaise question à votre professeur. Vous avez demandé à un expert en cybersécurité si un algorithme pouvait être piraté, ce à quoi la réponse est toujours oui, à l'exception d'une poignée d'algorithmes gênants, tels que les tampons à usage unique utilisés exactement de la bonne manière. Même dans ces cas, il y a des exploits à craindre.

AES-256 est un algorithme. Il peut être cassé. Si vous regardez l'histoire de la cryptographie, chaque algorithme finit par être cassé. C'est pourquoi nous créons de nouveaux algorithmes. La question est de savoir combien de temps il faut pour comprendre les maths pour le casser.

La vraie question à se poser est « quel est votre modèle de menace ? » Quelle sorte d'attaque essayez-vous d'empêcher? Créez-vous un verrou numérique sur un journal pour le protéger des regards indiscrets de votre sœur, ou êtes-vous Edward Snowden, en fuite de plusieurs agences de trois lettres avec des milliards de dollars de financement ?

AES-256 est actuellement étiqueté comme suffisant pour être utilisé par le gouvernement américain pour la transmission d'informations TOP SECRET/SCI. C'est à peu près le niveau de classification le plus élevé pour lequel ils pourraient l'effacer, donc le gouvernement américain est sacrément convaincu que personne ne peut briser AES-256 dans les délais requis pour protéger les plus grands secrets de notre nation.

(Enfin, presque. Ce que cela dit vraiment, c'est qu'ils sont convaincus que personne en dehors du gouvernement américain peut casser AES-256. Ce que vous pensez que cela dit pour savoir si le gouvernement américain, lui-même, peut le briser dépend de votre modèle de menace. et si vous vous engagez dans des discussions pour savoir si le papier d'aluminium résistant fait de meilleurs chapeaux ou non)

AES-256 - le chiffrement par bloc - pour autant que nous le sachions, n'a pas été brisé. Il n'a même pas été près d'être cassé. En revanche, nous ne pouvons pas prouver qu'il est sécurisé. Cela signifie qu'un algorithme capable de déchiffrer AES peut être trouvé. La plupart des chiffrements ne peuvent pas être éprouvé être en sécurité. Seuls quelques algorithmes tels que le one-time-pad sont sécurisés au sens de la théorie de l'information.

Le document que vous indiquez concerne les attaques clés connexes. Ces attaques sont en effet possibles et elles réduisent la force de l'AES pour des cas d'utilisation spécifiques à une valeur qui casse théoriquement le chiffre. Fondamentalement, vous ne devez pas utiliser AES-256 pour créer une fonction de hachage. En pratique, pour atteindre la confidentialité, AES-256 est toujours considéré comme sécurisé, même contre les attaques utilisant la cryptanalyse quantique.

Avoir un chiffrement par bloc sécurisé ne fournit cependant aucune sécurité en soi. Vous avez besoin d'un système sécurisé, et pour ce système sécurisé vous mai besoin d'un protocole sécurisé. Et dans ce protocole, vous mai besoin d'un schéma ou d'un mode de fonctionnement (comme GCM). Et ce schéma de cryptage peut nécessiter un chiffrement par bloc. Et ce chiffrement par bloc peut être AES-256.

L'algorithme AES-256 lui-même nécessite une clé secrète bien protégée et une implémentation sécurisée - telle qu'une protection contre les attaques par canal latéral, le cas échéant - pour être considéré comme sécurisé. Il pourrait par exemple être rendu conforme FIPS.

Bien que l'algorithme AES-256 soit considéré comme sécurisé, cela ne signifie pas que votre schéma, protocole ou système est sécurisé. Pour cela, vous avez besoin d'un modèle de menace et montrez qu'il est pratiquement sécurisé contre tous les vecteurs d'attaque possibles.

TLDR : lors de la création d'un système sécurisé, vous pouvez utiliser AES-256, il est considéré comme sécurisé même si cela ne peut pas être prouvé. D'autres aspects du système sont beaucoup plus susceptibles d'échouer que AES-256 - le chiffrement par bloc en lui-même.


1 réponse 1

  1. La propagation du nombre d'articles dans le sac à dos ne conduit pas à des solutions optimales.
  2. Un La solution consiste à ajouter une troisième dimension. C'est assez simple mais il est nécessaire de prendre en compte certains faits pour le faire. Notez cependant que ce n'est pas la seule alternative

Dans ce qui suit, je suppose que vous connaissez la solution basée sur la programmation dynamique. En particulier, Je ne discuterai pas de la façon de parcourir le tableau à l'envers pour déterminer la solution.

Concentrons-nous d'abord sur le cas typique : le nombre d'articles est illimité. Dans ce cas, vous construisez simplement une table $T$ où $T_$ contient la valeur optimale lorsque la capacité globale du sac à dos est égale à $i$ et que seuls les premiers $j$ sont pris en compte. D'ici:

où $w_j$ et $v_j$ représentent respectivement le poids et la valeur du $j$-ième élément. Si $C$ est la capacité globale de votre sac à dos et qu'il y a au total $N$ articles la solution optimale est donnée par $T_$. Cet algorithme est connu pour fonctionner en temps pseudo-polynomial et l'une de ses beautés est qu'il ne considère que les combinaisons qui correspondent à la capacité maximale.

Cependant, cela ne suffit pas lors de l'ajout de votre contrainte : un nombre maximum d'éléments $p$. La raison en est que la formule de récurrence précédente ne prend pas en compte différentes combinaisons d'éléments :

  1. Premièrement, si $T_<(T_+v_j)$ puis $T_=(T_+v_j)$ pour que le $j$-ième élément soit ajouté au sac à dos malgré le nombre maximum d'éléments pris en compte, $p$ ---pour que vous soyez en train de violer votre contrainte. Eh bien, vous pourriez être tenté ici d'appliquer la formule précédente en gardant une trace du nombre d'éléments insérés à chaque étape et de ne pas en ajouter d'autres si le nombre d'éléments actuellement dans le sac à dos dépasse $p$ mais,
  2. Second, if $T_>(T_+v_j)$ then $T_=T_$ so that this item is not added but that might be a big mistake in case the optimal solution $T_$ already consists of the maximum number of items to insert into the knapsack. The reason is that we are not properly comparing: on one hand, to preserve the optimal solution consisting of $p$ items selected among the previous $(j-1)$ on the other hand, to insert the $j$-th item and, additionally consider the best subset with $(p-1)$ items among the previous $(j-1)$.

So that a first solution consists of adding a third dimension. For your case, let $T_$ be the optimal solution when the capacity of the knapsack is $i$, only the first $j$ items are considered and it is not allowed to put more than $k$ items in the knapsack. À présent,

  • If you are computing $T_$ for a number of items strictly less or equal than the number of items that can be inserted ($jleq k$) then proceed as usual but using the same value of $k$: $T_ =max<>, T_+v_j>$
  • Now, if you have to compute $T_$ for a number of items strictly larger than the number of items that can be inserted ($j> k$) then: $T_ =max<>, T_+v_j>$

The first expression should be clear. The second works since the $(k-1)$-th layer of the table $T$ keeps track of the best combination of $(k-1)$ items among the first $(j-1)$ as required above.

An efficient implementation of this algorithm does not need to compute $T_$ for all $k$. Note that the preceding recurrence relationships relate layer $k$ with $(k-1)$ and thus, it is possible to alternate between two successive layers (e.g., if you are interested in the optimal solution with $k=4$ you just use two consecutive layers: 0 and 1, 1 and 2, 2 and 3, 3 and 4 and you're done). In other words, this algorithm takes twice the memory required by the traditional approach based on dynamic programming and thus, it can be still run in pseudo-polynomial time.

Be aware, however, that this is not the only solution! And there is another you might find more elegant. In the preceding formulae, we retrieved the optimal solution which consisted of no more than $(k-1)$ items among the first $(j-1)$ as $T_$. However, it should be clear that this is precisely equal to $maxlimits_<>>$ just by using the original table!! ie., the optimal solution with no more than $k$ items can be also retrieved by considering the optimal solutions with 1 item, 2 items, 3 items, . $(j-1)$ items . To make this formulation work you should also keep track of the number of items considered in every partial solution so that you will need two integers per cell. This memory occupation results in precisely the same memory requirements of the algorithm shown above (using a third dimension in the form of layers $k$).