gorgonia
v0.9.18
Gorgonia est une bibliothèque qui aide à faciliter l'apprentissage automatique en Go. Écrivez et évaluez les équations mathématiques impliquant facilement des tableaux multidimensionnels. Si cela ressemble à Theano ou TensorFlow, c'est parce que l'idée est assez similaire. Plus précisément, la bibliothèque est assez bas, comme Theano, mais a des objectifs plus élevés comme TensorFlow.
Gorgonia:
L'objectif principal de Gorgonia est d'être une bibliothèque basée sur l'apprentissage machine / calcul graphique très performant qui peut évoluer sur plusieurs machines. Il devrait apporter l'attrait de GO (simple compilation et processus de déploiement) au monde ML. C'est un long chemin à partir de là actuellement, cependant, les pas de bébé sont déjà là.
L'objectif secondaire pour Gorgonia est de fournir une plate-forme pour l'exploration des choses non standard d'apprentissage en profondeur et de réseau neuronal. Cela inclut des choses comme l'apprentissage néo-hebbian, les algorithmes de coupe d'angle, les algorithmes évolutifs, etc.
La principale raison d'utiliser Gorgonia est le confort des développeurs. Si vous utilisez une pile GO de manière approfondie, vous avez maintenant accès à la possibilité de créer des systèmes d'apprentissage automatique prêts pour la production dans un environnement avec lequel vous connaissez déjà et que vous êtes déjà à l'aise.
ML / AI dans son ensemble est généralement divisé en deux étapes: l'étape expérimentale où l'on construit divers modèles, tests et reteste; et l'état déployé où un modèle après avoir été testé et joué avec, est déployé. Cela nécessite différents rôles comme le data scientist et l'ingénieur de données.
En règle générale, les deux phases ont des outils différents: Python (pytorch, etc.) est couramment utilisé pour l'étape expérimentale, puis le modèle est réécrit dans un langage plus performant comme C ++ (en utilisant DLIB, MLPACK, etc.). Bien sûr, de nos jours, l'écart se termine et les gens partagent fréquemment les outils entre eux. TensorFlow est un de ces outils qui comble l'écart.
Gorgonia vise à faire de même mais pour l'environnement Go. Gorgonia est actuellement assez performant - ses vitesses sont comparables aux implémentations CPU de Pytorch et Tensorflow. Les implémentations GPU sont un peu capricieuses à comparer en raison de la forte taxe de CGO, mais soyez assuré qu'il s'agit d'un domaine d'amélioration active.
Le package est go-gettable: go get -u gorgonia.org/gorgonia .
Gorgonia est compatible avec les modules GO.
La documentation, les références et les tutoriels à jour sont présents sur le site officiel de Gorgonia à https://gorgonia.org.
Le projet de Gorgonia a une chaîne Slack sur Gopherslack, ainsi qu'un compte Twitter. Les mises à jour officielles et les annonces seront publiées sur ces deux sites.
Gorgonia fonctionne en créant un graphique de calcul puis en l'exécutant. Considérez-le comme un langage de programmation, mais se limite aux fonctions mathématiques et n'a pas de capacité de ramification (non si / ensuite ou boucles). En fait, c'est le paradigme dominant auquel l'utilisateur doit être utilisé. Le graphique de calcul est un AST.
Le CNTK de Microsoft, avec son Brainscript, est peut-être le meilleur pour illustrer l'idée que la création d'un graphique de calcul et l'exécution des graphiques de calcul sont des choses différentes et que l'utilisateur devrait être dans différents modes de pensée lorsqu'ils y font.
Alors que l'implémentation de Gorgonia n'applique pas la séparation de la pensée en ce qui concerne le Brainscript de CNTK, la syntaxe aide un peu.
Voici un exemple - disons que vous souhaitez définir une expression mathématique z = x + y . Voici comment vous le feriez:
package gorgonia_test
import (
"fmt"
"log"
. "gorgonia.org/gorgonia"
)
// Basic example of representing mathematical equations as graphs.
//
// In this example, we want to represent the following equation
// z = x + y
func Example_basic () {
g := NewGraph ()
var x , y , z * Node
var err error
// define the expression
x = NewScalar ( g , Float64 , WithName ( "x" ))
y = NewScalar ( g , Float64 , WithName ( "y" ))
if z , err = Add ( x , y ); err != nil {
log . Fatal ( err )
}
// create a VM to run the program on
machine := NewTapeMachine ( g )
defer machine . Close ()
// set initial values then run
Let ( x , 2.0 )
Let ( y , 2.5 )
if err = machine . RunAll (); err != nil {
log . Fatal ( err )
}
fmt . Printf ( "%v" , z . Value ())
// Output: 4.5
} Vous pourriez noter que c'est un peu plus verbeux que les autres packages de nature similaire. Par exemple, au lieu de compiler à une fonction appelable, Gorgonia se compile spécifiquement dans un *program qui nécessite un *TapeMachine pour s'exécuter. Il nécessite également un appel manuel Let(...) .
L'auteur aimerait affirmer que c'est une bonne chose - déplacer sa pensée à la pensée basée sur la machine. Cela aide beaucoup à déterminer où les choses pourraient mal tourner.
De plus, il n'y a pas de support pour la ramification - c'est-à-dire qu'il n'y a pas de conditionnels (si / else) ou de boucles. L'objectif n'est pas de construire un ordinateur Turing-Complete.
Plus d'exemples sont présents dans l' example de sous-dossier du projet, et des tutoriels étape par étape sont présents sur le site Web principal
Gorgonia est livré avec le support CUDA hors de la boîte. Veuillez consulter la documentation de référence sur le fonctionnement de Cuda sur le site Web de Gorgonia.org, ou passez au tutoriel.
Nous utilisons Semver 2.0.0 pour notre versioning. Avant 1.0, les API de Gorgonia devraient changer un peu. L'API est définie par les fonctions, variables et méthodes exportées. Pour la santé mentale des développeurs, il existe des différences mineures à Semver que nous appliquerons avant la version 1.0. Ils sont énumérés ci-dessous:
L'API de Gorgonia est en ce moment, non considérée comme stable. Il sera stable à partir de la version 1.0 en avant.
Gorgonia prend en charge 2 versions sous la branche maître de Go. Cela signifie que Gorgonia prendra en charge la version actuelle publiée de GO, et jusqu'à 4 versions précédentes - fournir quelque chose ne se casse pas. Dans la mesure du possible, une cale sera fournie (pour des choses comme les nouvelles API sort ou math/bits qui sont sorties dans GO 1.9).
La version actuelle de GO est 1.13.1. La première version prend en charge Gorgonia est Go 1.11.x mais Gonum ne prend en charge que 1,12+. Par conséquent, la version minimum GO pour exécuter la branche maître est Go> 1.12.
Gorgonia continue:
Si vous avez testé Gorgonia sur d'autres plateformes, veuillez mettre à jour cette liste.
Gorgonia utilise des instructions d'assembleur pures pour accélérer certaines opérations mathématiques. Malheureusement, seul AMD64 est pris en charge.
De toute évidence, comme vous lisez très probablement ceci sur GitHub, Github constituera la majeure partie du workflow pour contribuer à ce package.
Voir aussi: contribution.md
Toutes les contributions sont les bienvenues. Cependant, il existe une nouvelle classe de contributeurs, appelés contributeurs importants.
Un contributeur important a montré une compréhension approfondie du fonctionnement de la bibliothèque et / ou de ses environs. Voici des exemples de ce qui constitue une contribution significative:
La liste importante des contributeurs sera mise à jour une fois par mois (si quelqu'un utilise même Gorgonia).
La meilleure façon de supporter en ce moment est d'ouvrir un billet sur GitHub.
runtime.GC() dans les tests? La réponse à ceci est simple - la conception du package utilise CUDA d'une manière particulière: en particulier, un appareil et un contexte CUDA sont liés à une VM , plutôt qu'au niveau du package. Cela signifie que pour chaque VM créée, un contexte CUDA différent est créé par appareil par VM . De cette façon, toutes les opérations joueront bien avec d'autres applications qui peuvent utiliser CUDA (cela doit cependant être testé par le stress).
Les contextes CUDA ne sont détruits que lorsque la VM obtient des ordures collectées (à l'aide d'une fonction Finalizer). Dans les tests, environ 100 VM sont créés et la collecte des ordures peut pour la plupart peut être considérée comme aléatoire. Cela conduit à des cas où le GPU manque de mémoire car il y a trop de contextes utilisés.
Par conséquent, à la fin de tous les tests qui peuvent utiliser GPU, un appel runtime.GC() est fait pour forcer la collecte des ordures, libérant des souvenirs de GPU.
En production, il est peu probable que l'on commence à autant de machines VM , donc ce n'est pas un problème. S'il y en a, ouvrez un billet sur GitHub, et nous chercherons à ajouter une méthode Finish() pour les VM S.
Gorgonia est sous licence dans une variante d'Apache 2.0. C'est la même chose que la licence Apache 2.0, sauf ne pas pouvoir profiter commercialement directement du package, sauf si vous êtes un contributeur important (par exemple, en fournissant un support commercial pour le package). Il est parfaitement bien de profiter directement d'un dérivé de Gorgonia (par exemple, si vous utilisez Gorgonia comme bibliothèque dans votre produit)
Tout le monde est toujours autorisé à utiliser Gorgonia à des fins commerciales (par exemple: l'utiliser dans un logiciel pour votre entreprise).
Il y a très peu de dépendances que Gorgonia utilise - et elles sont toutes assez stables, donc pour l'instant, il n'est pas nécessaire d'outils de vente. Ce sont la liste des packages externes que Gorgonia appelle, classés par ordre de confiance que ce package a (les sous-packages sont omis):
| Emballer | Utilisé pour | Vitalité | Notes | Licence |
|---|---|---|---|---|
| gonum / graphique | Tri *ExprGraph | Vital. Le retrait signifie que Gorgonia ne fonctionnera pas | Le développement de Gorgonia s'est engagé à suivre la version la plus mise à jour | Licence Gonum (MIT / BSD-like) |
| Gonum / Blas | Opérations d'algèbre linéaire du sous-package du tenseur | Vital. Le retrait signifie que le gorgonial ne fonctionnera pas | Le développement de Gorgonia s'est engagé à suivre la version la plus mise à jour | Licence Gonum (MIT / BSD-like) |
| cu | Pilotes Cuda | Nécessaire pour les opérations CUDA | Même mainteneur que Gorgonia | MIT / BSD |
| math32 | Opérations float32 | Peut être remplacé par float32(math.XXX(float64(x))) | Même mainteneur que Gorgonia, même API que le package math intégré | MIT / BSD |
| HM | Système de type pour Gorgonia | Les graphiques de Gorgonia sont assez étroitement associés au système de type | Même mainteneur que Gorgonia | MIT / BSD |
| VECF64 | Opérations optimisées []float64 | Peut être généré dans le package tensor/genlib . Cependant, de nombreuses optimisations ont été faites / seront faites | Même mainteneur que Gorgonia | MIT / BSD |
| VECF32 | opérations optimisées []float32 | Peut être généré dans le package tensor/genlib . Cependant, de nombreuses optimisations ont été faites / seront faites | Même mainteneur que Gorgonia | MIT / BSD |
| ensemble | Diverses opérations de set | Peut être facilement remplacé | API stable depuis 1 an | Définir la licence (MIT / BSD-like) |
| gabillard | Utilisé pour l'impression de graphiques | L'impression graphique n'est que vitale pour le débogage. Gorgonia peut survivre sans, mais avec une perte de fonctions majeure (mais sans doute non vitale) | Dernière mise à jour le 12 avril 2017 | Licence Gobraphviz (Apache 2.0) |
| RNG | Utilisé pour implémenter des fonctions d'assistance pour générer des poids initiaux | Peut être remplacé assez facilement. Gorgonia peut aussi se passer des fonctions de commodité | Licence RNG (Apache 2.0) | |
| erreurs | Error Emballage | Gorgonia ne mourra pas sans lui. En fait, Gorgonia a également utilisé des goerrors / erreurs dans le passé. | API stable depuis 6 mois | Licence d'erreurs (MIT / BSD-like) |
| Gonum / Mat | Compatibilité entre Tensor et matrice de Gonum | Le développement de Gorgonia s'est engagé à suivre la version la plus mise à jour | Licence Gonum (MIT / BSD-like) | |
| témoigner / affirmer | Essai | Peut se passer mais sera une douleur massive dans le cul pour tester | témoigner de licence (MIT / BSD-like) |
Ce sont les packages et les bibliothèques qui ont inspiré et qui ont été adaptés en train d'écrire Gorgonia (les packages Go qui ont été utilisés ont déjà été déclarés ci-dessus):
| Source | Comment il est utilisé | Licence |
|---|---|---|
| Nombant | Inspiré de grandes portions. Algorithmes directement adaptés pour quelques méthodes (explicitement étiquetées dans les documents) | MIT / BSD comme. Licence Numpy |
| Theano | Inspiré de grandes portions. (Incertain: nombre d'algorithmes directement adaptés) | Licence Theano de type MIT / BSD |
| Caffe | im2col et col2im directement tirés de Caffe. Algorithmes de convolution inspirés des méthodes de Caffee originales | Licence de caffes |
