gorgonia
v0.9.18
Gorgonia é uma biblioteca que ajuda a facilitar o aprendizado de máquina em Go. Escreva e avalie as equações matemáticas envolvendo matrizes multidimensionais facilmente. Se isso soa como Theano ou Tensorflow, é porque a ideia é bastante semelhante. Especificamente, a biblioteca é bastante baixa, como Theano, mas tem objetivos mais altos como o Tensorflow.
Gorgonia:
O objetivo principal para a Gorgonia é ser uma biblioteca baseada em Machine Learning/Computação de Machine, que pode ser escalada em várias máquinas. Deve levar o apelo do GO (processo simples de compilação e implantação) para o mundo da ML. Atualmente, é um longo caminho a partir daí, no entanto, os passos do bebê já estão lá.
O objetivo secundário para a Gorgonia é fornecer uma plataforma para a exploração de coisas relacionadas a redes profundas e relacionadas à rede neural não padrão. Isso inclui coisas como aprendizado neo-hebbiano, algoritmos de corte de canto, algoritmos evolutivos e similares.
O principal motivo para usar Gorgonia é o conforto do desenvolvedor. Se você estiver usando uma pilha Go extensivamente, agora você tem acesso à capacidade de criar sistemas de aprendizado de máquina pronto para produção em um ambiente com o qual você já está familiarizado e com o qual se sinta confortável.
ML/AI em geral é geralmente dividido em dois estágios: o estágio experimental onde se constrói vários modelos, testes e testes; e o estado implantado em que um modelo após ser testado e tocado é implantado. Isso requer funções diferentes, como cientista de dados e engenheiro de dados.
Normalmente, as duas fases têm ferramentas diferentes: o Python (pytorch, etc) é comumente usado para o estágio experimental e, em seguida, o modelo é reescrito em um idioma mais performante, como C ++ (usando DLIB, MLPACK etc). Obviamente, hoje em dia a lacuna está fechando e as pessoas freqüentemente compartilham as ferramentas entre elas. O TensorFlow é uma dessas ferramentas que preenche a lacuna.
Gorgonia pretende fazer o mesmo, mas para o ambiente Go. Atualmente, a Gorgonia é bastante executada - suas velocidades são comparáveis às implementações da CPU da Pytorch e Tensorflow. As implementações da GPU são um pouco exigentes para comparar devido ao imposto pesado do CGO, mas tenha certeza de que essa é uma área de melhoria ativa.
O pacote é go -gettable: go get -u gorgonia.org/gorgonia .
Gorgonia é compatível com os módulos GO.
A documentação, referências e tutoriais atualizados estão presentes no site oficial da Gorgonia em https://gorgonia.org.
O projeto da Gorgonia tem um canal de folga no Gopherslack, bem como uma conta do Twitter. Atualizações e anúncios oficiais serão publicados nesses dois sites.
Gorgonia funciona criando um gráfico de computação e executando -o. Pense nisso como uma linguagem de programação, mas é limitada às funções matemáticas e não possui capacidade de ramificação (nem se/então ou loops). De fato, este é o paradigma dominante que o usuário deve ser usado para pensar. O gráfico de computação é um AST.
O CNTK da Microsoft, com seu BRAINScript, é talvez o melhor em exemplificar a ideia de que a criação de um gráfico de computação e a execução dos gráficos de computação são coisas diferentes e que o usuário deve estar em diferentes modos de pensamento ao fazer sobre eles.
Embora a implementação de Gorgonia não aplique a separação do pensamento, no que diz respeito ao Bronscript da CNTK, a sintaxe ajuda um pouco.
Aqui está um exemplo - diga que você deseja definir uma expressão matemática z = x + y . Veja como você faria:
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
} Você pode observar que é um pouco mais detalhado do que outros pacotes de natureza semelhante. Por exemplo, em vez de compilar uma função chamada, a Gorgonia compila especificamente em um *program que exige que uma *TapeMachine seja executada. Também requer uma chamada manual Let(...) .
O autor gostaria de afirmar que isso é uma coisa boa - mudar o pensamento de alguém para o pensamento baseado em máquina. Ajuda muito a descobrir onde as coisas podem dar errado.
Além disso, não há suporte para ramificação - isto é, não há condicionais (se/else) ou loops. O objetivo não é construir um computador com preenchimento de Turing.
Mais exemplos estão presentes na subpasta example do projeto, e os tutoriais passo a passo estão presentes no site principal
Gorgonia vem com o suporte da CUDA. Consulte a documentação de referência sobre como o CUDA funciona no site gorgonia.org ou pule para o tutorial.
Usamos o Semver 2.0.0 para o nosso versão. Antes de 1.0, espera -se que as APIs da Gorgonia mudem bastante. A API é definida pelas funções, variáveis e métodos exportados. Para a sanidade dos desenvolvedores, existem pequenas diferenças em Semver que aplicaremos antes da versão 1.0. Eles são enumerados abaixo:
A API de Gorgonia é a partir de agora, não é considerada estável. Será estável da versão 1.0 avançada.
Gorgonia suporta 2 versões abaixo do ramo principal do GO. Isso significa que a Gorgonia apoiará a versão atual lançada do GO e até 4 versões anteriores - fornecer algo não quebra. Sempre que possível, um calço será fornecido (para coisas como novas APIs sort ou math/bits que saíram em Go 1.9).
A versão atual do GO é 1.13.1. A versão mais antiga que Gorgonia suporta é o Go 1.11.x, mas o Gonum suporta apenas 1,12+. Portanto, a versão GO mínima para executar a filial principal é GO> 1,12.
Gorgonia continua:
Se você testou a Gorgonia em outras plataformas, atualize esta lista.
Gorgonia usa algumas instruções de montador puro para acelerar algumas operações matemáticas. Infelizmente, apenas o AMD64 é suportado.
Obviamente, como você provavelmente está lendo isso no Github, o Github formará a maior parte do fluxo de trabalho para contribuir para este pacote.
Veja também: Contribuindo.md
Todas as contribuições são bem -vindas. No entanto, existe uma nova classe de colaboradores, chamada contribuintes significativos.
Um colaborador significativo mostrou uma compreensão profunda de como a biblioteca funciona e/ou seus arredores. Aqui estão exemplos do que constitui uma contribuição significativa:
A lista de colaboradores significativos será atualizada uma vez por mês (se alguém usar a Gorgonia).
A melhor maneira de apoiar agora é abrir um ingresso no Github.
runtime.GC() nos testes? A resposta para isso é simples - o design do pacote usa CUDA de uma maneira particular: especificamente, um dispositivo e contexto CUDA estão ligados a uma VM , em vez de no nível do pacote. Isso significa que para cada VM criada, um contexto CUDA diferente é criado por dispositivo por VM . Dessa forma, todas as operações jogarão bem com outras aplicações que podem estar usando o CUDA (isso precisa ser testado pelo estresse).
Os contextos CUDA são destruídos apenas quando a VM recebe o lixo coletado (com a ajuda de uma função de finalizador). Nos testes, cerca de 100 VM são criados e a coleta de lixo na maioria das vezes pode ser considerada aleatória. Isso leva a casos em que a GPU fica sem memória, pois há muitos contextos sendo usados.
Portanto, no final de quaisquer testes que possam usar a GPU, uma chamada de runtime.GC() é feita para forçar a coleta de lixo, liberando memórias da GPU.
Na produção, é improvável que se inicie que muitas VM , portanto, não é um problema. Se houver, abra um ingresso no Github e examinaremos o método de Finish() para a VM S.
A Gorgonia é licenciada sob uma variante do Apache 2.0. É o mesmo que a licença Apache 2.0, exceto não ser capaz de lucrar comercialmente diretamente do pacote, a menos que você seja um colaborador significativo (por exemplo, fornecendo suporte comercial para o pacote). É perfeitamente bom lucrar diretamente de um derivado da Gorgonia (por exemplo, se você usar a Gorgonia como uma biblioteca em seu produto)
Todos ainda podem usar a Gorgonia para fins comerciais (por exemplo: usá -lo no software para o seu negócio).
Existem muito poucas dependências que a Gorgonia usa - e todos eles são bastante estáveis; portanto, a partir de agora não há necessidade de ferramentas de vender. Estes são a lista de pacotes externos que a Gorgonia chama, classificada em ordem de confiança que este pacote possui (os sub-pacotes são omitidos):
| Pacote | Usado para | Vitalidade | Notas | Licença |
|---|---|---|---|---|
| gonum/gráfico | Classificação *ExprGraph | Vital. Remoção significa que Gorgonia não funcionará | O desenvolvimento da Gorgonia está comprometido em acompanhar a versão mais atualizada | Licença Gonum (MIT/BSD) |
| gonum/blas | Operações de álgebra linear de subpackage tensor | Vital. Remoção significa que o Gorgonial não funcionará | O desenvolvimento da Gorgonia está comprometido em acompanhar a versão mais atualizada | Licença Gonum (MIT/BSD) |
| Cu | Drivers Cuda | Necessário para operações de CUDA | Mesmo mantenedor que Gorgonia | MIT/BSD |
| Math32 | Operações float32 | Pode ser substituído por float32(math.XXX(float64(x))) | Mesmo mantenedor que Gorgonia, a mesma API que o pacote math embutido | MIT/BSD |
| HM | Sistema de tipo para Gorgonia | Os gráficos de Gorgonia estão bem acoplados ao sistema de tipos | Mesmo mantenedor que Gorgonia | MIT/BSD |
| Vecf64 | operações otimizadas []float64 | Pode ser gerado no pacote tensor/genlib . No entanto, muitas otimizações foram feitas/serão feitas | Mesmo mantenedor que Gorgonia | MIT/BSD |
| VECF32 | otimizados []float32 | Pode ser gerado no pacote tensor/genlib . No entanto, muitas otimizações foram feitas/serão feitas | Mesmo mantenedor que Gorgonia | MIT/BSD |
| definir | Várias operações definidas | Pode ser facilmente substituído | API estável no último 1 ano | Defina a licença (MIT/BSD) |
| GographViz | Usado para imprimir gráficos | A impressão de gráficos é vital apenas para depuração. Gorgonia pode sobreviver sem, mas com uma perda de característica importante (mas sem dúvida não -vital) | Última atualização em 12 de abril de 2017 | Licença GographViz (Apache 2.0) |
| rng | Usado para implementar funções auxiliares para gerar pesos iniciais | Pode ser substituído com bastante facilidade. Gorgonia pode fazer sem as funções de conveniência também | Licença RNG (Apache 2.0) | |
| erros | Erro embrulhado | Gorgonia não morre sem ele. De fato, Gorgonia também usou Goerrors/erros no passado. | API estável nos últimos 6 meses | Licença de erros (MIT/BSD) |
| Gonum/Mat | Compatibilidade entre Tensor e Matrix de Gonum | O desenvolvimento da Gorgonia está comprometido em acompanhar a versão mais atualizada | Licença Gonum (MIT/BSD) | |
| testemunhar/afirmar | Teste | Pode ficar sem, mas será uma dor enorme na bunda para testar | testemunhas de licença (MIT/BSD) |
Estes são os pacotes e bibliotecas que se inspiraram e foram adaptados no processo de escrita de Gorgonia (os pacotes Go que foram usados já foram declarados acima):
| Fonte | Como é usado | Licença |
|---|---|---|
| Numpy | Inspirou grandes porções. Algoritmos diretamente adaptados para alguns métodos (explicitamente rotulados nos documentos) | MIT/BSD. Licença Numpy |
| Theano | Inspirou grandes porções. (Independente: Número de algoritmos diretamente adaptados) | MIT/BSD Licença de Theano |
| Caffe | im2col e col2im retirados diretamente de Caffe. Algoritmos de convolução inspirados nos métodos originais de Caffee | Licença de Caffe |
