J'ai un problème de gestion de données scientifiques qui semble général, mais je ne trouve pas de solution existante ou même une description de celle-ci, que j'ai longtemps intrigué. Je suis sur le point de me lancer dans une réécriture majeure (python) mais je pensais jeter un dernier coup d'œil sur les solutions existantes, donc je peux m'en débarrasser et revenir à la biologie, ou au moins apprendre un langage approprié pour mieux googler . Le problème: J'ai des attributs de données coûteux (heures à jours à calculer) et grands (Go) qui sont généralement construits comme des transformations d'un ou plusieurs autres attributs de données. J'ai besoin de garder une trace exacte de la façon dont ces données sont construites afin que je puisse les réutiliser comme entrée pour une autre transformation si cela correspond au problème (construit avec les bonnes valeurs de spécification) ou construire de nouvelles données si nécessaire. Bien que cela ne devrait pas avoir d'importance, je commence généralement par des informations de biologie moléculaire quelque peu hétérogènes, à valeur ajoutée, par exemple, des génomes avec des gènes et des protéines annotés par d'autres chercheurs. J'ai besoin de combiner et comparer ces données pour faire mes propres inférences. Un certain nombre d'étapes intermédiaires sont souvent nécessaires, et ceux-ci peuvent être coûteux. En outre, les résultats finaux peuvent devenir l'entrée de transformations supplémentaires. Toutes ces transformations peuvent être effectuées de plusieurs façons: en limitant avec des données initiales différentes (par exemple en utilisant différents organismes), en utilisant différentes valeurs de paramètres dans les mêmes inférences, ou en utilisant différents modèles d'inférence, etc. de manière non planifiée. J'ai besoin de savoir quelles données j'ai (quels paramètres ou spécifications le définissent pleinement), à la fois pour que je puisse les réutiliser si nécessaire, ainsi que pour l'intégrité scientifique générale.python solutions pour gérer le graphique de dépendance aux données scientifiques par valeurs de spécification
Mes efforts en général: Je conçois mes classes python avec le problème de la description en tête. Tous les attributs de données construits par un objet de classe sont décrits par un seul ensemble de valeurs de paramètres. J'appelle ces paramètres ou spécifications de définition les «def_specs», et ces def_specs avec leurs valeurs la «forme» des atts de données. L'état global des paramètres globaux du processus peut être assez important (par exemple, une centaine de paramètres), mais les données fournies par une classe quelconque n'en nécessitent qu'un petit nombre, au moins directement. Le but est de vérifier si les données précédemment construites sont appropriées en testant si leur forme est un sous-ensemble de l'état du paramètre global.
Dans une classe, il est facile de trouver les attributs def_spec qui définissent la forme en examinant le code. Le frottement survient lorsqu'un module a besoin d'une donnée att d'un autre module. Ces attributs de données auront leur propre forme, peut-être transmise en tant qu'args par l'objet appelant, mais plus souvent filtrée à partir de l'état du paramètre global. La classe appelante devrait être augmentée avec la forme de ses dépendances afin de maintenir une description complète de ses données. En théorie, cela pourrait être fait manuellement en examinant le graphe de dépendance, mais ce graphe peut devenir profond, et il y a beaucoup de modules, que je change et j'ajoute constamment, et ... Je suis trop paresseux et négligent pour le faire main. Par conséquent, le programme découvre dynamiquement la forme complète des données en effectuant le suivi des appels vers d'autres attributs de classes et en repoussant leur forme vers l'appelant via une pile gérée d'appels __get__. Comme je le réécris, je trouve que j'ai besoin de contrôler strictement l'accès aux attributs de mes classes builder pour éviter que des informations arbitraires n'affectent les données. Heureusement, Python facilite cela avec des descripteurs.
Je stocke la forme des données dans une base de données de sorte que je puisse demander si les données appropriées (c'est-à-dire leur forme est un sous-ensemble de l'état actuel des paramètres) existent déjà. Dans ma réécriture, je passe de mysql via le grand SQLAlchemy à un objet db (ZODB ou couchdb?) Car la table de chaque classe doit être modifiée lorsque des def_specs supplémentaires sont découvertes, ce qui est pénible, et parce que certains des def_specs sont listes python ou dicts, qui sont une peine à traduire en sql.Je ne pense pas que cette gestion des données puisse être séparée de mon code de transformation de données en raison de la nécessité d'un contrôle strict des attributs, bien que j'essaie de le faire autant que possible. Je peux utiliser les classes existantes en les enveloppant avec une classe qui fournit leur def_specs en tant qu'attributs de classe, et la gestion de DB via des descripteurs, mais ces classes sont terminales en ce qu'aucune autre découverte de forme de dépendance supplémentaire ne peut avoir lieu.
Si la gestion des données ne peut pas être facilement séparée de la construction de données, je suppose qu'il est peu probable qu'il existe une solution prête à l'emploi, mais un millier de solutions spécifiques. Peut-être y a-t-il un modèle applicable? J'apprécierais toute allusion à la façon de regarder ou de mieux décrire le problème. Pour moi, cela semble un problème général, bien que la gestion de données en couches profondes soit peut-être en contradiction avec les vents dominants du web.
Votre description des exigences pour les attributs de données me rappelle vaguement "Arbres!", "Structural Sharing" diapositives de http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey par Rich Hickey (Clojure) 0:41:10 – jfs
Merci pour la suggestion - ça a l'air profond, donc je vais devoir prendre du temps avec ça. – ricopan
Ok regardé la conversation et a grokked un peu de manière générale. Je n'avais jamais pensé au temps explicitement. En partant de mon problème spécifique, j'ai vu la nécessité de faire en sorte que mes objets agissent davantage comme des fonctions fournissant des objets immuables comme seul moyen de garantir l'intégrité des données avec des «formes» connues. J'avais seulement un peu réfléchi à la concurrence, mais cela renforçait l'idée que mes classes devaient essentiellement agir comme des fonctions et avoir un contrôle strict des attributs. Merci encore. Je dois m'en tenir à la pratique, mais cela me donne des idées et une terminologie à utiliser, et un peu de foi. – ricopan