Scikit-learn: Máquina de vetor de relevância (RVM)

Eu teria que ler sobre isso novamente, mas em geral acho que RVMs seriam uma boa adição.
dlib é licenciado por boost, que deve ser compatível. Pode não ser tão fácil de embrulhar por causa do estilo de codificação de reforço pesado, no entanto.
O problema está otimizado usando SMO? É sensato se implementarmos o SMO?

Tenho que pegar meu bispo.

Qual é a relação entre ARD e RVM? O RVM é apenas a versão de "função básica" do ARD?

Aliás, alguém já se incomodou com o fato de que a seção Generalized Linear Models não contém nenhum modelo generalizado?

Ok, então devemos usar o sequential sparse learning algorithm Bishop p. 352 seguindo eu acho?
Conheça a si mesmo;)

Eu me pergunto se existe um método semelhante para ARD? Isso seria legal, pois a implementação atual do ARD é bastante lenta: - /

Não, a implementação do RVM definitivamente não usa SMO. Acho que SMO só é usado para otimização de SVM.
Sim, devemos usar sequential sparse learning algorithm na referência 1, página 7. (está no bispo p 352? Qual deles). Este algoritmo é "simples" o suficiente e podemos escrevê-lo sem usar dlib. Eu estava pensando em escrevê-lo em python e, em seguida, usar cython para otimização. Nesse caso, podemos aproveitar ao máximo a implementação do matlab. O que você acha?
De qualquer forma, deve ser possível escrever em C ++. Mas, para isso, precisaremos de uma boa biblioteca de álgebra linear em C ++. Não tenho certeza se por padrão o scikit-learn vem com um.

Bishop é "Machine Learning and Pattern Recognition".

O algoritmo provavelmente não é completamente fácil de acertar. Se você quiser começar com isso, com certeza será um projeto maior. Se você está interessado e deseja implementá-lo de alguma forma, vá em frente.

Implementá-lo também é um pouco diferente de colocá-lo no scikit-learn. Isso também envolve escrever testes, documentação e um guia do usuário - e um código bonito.

Para uma primeira tentativa, você definitivamente deve usar apenas numpy. Ele usa blas internamente e, portanto, é bastante rápido.
Acelerar usando o Cython só faz sentido se houver muita sobrecarga do python. Se todo o tempo é gasto em chamadas BLAS, usar Cython não faz muito sentido.

OK para Cython e numpy. Eu não sabia que o bispo falava sobre RVM.
Para o relacionamento ARD e RVM. Não sei muito sobre ARD. Mas na referência 2 os autores afirmaram que o RVM se baseia no ARD: "Chamamos aqueles vetores de treinamento associados aos demais vetores de 'relevância' de pesos diferentes de zero, em deferência ao princípio da determinação automática de relevância que motiva a abordagem apresentada". (213) linha 8.
Enfim, como funciona o ARD?

ARD também é explicado no livro do bispo e no guia do usuário . Ele coloca uma diagonal gaussiana antes dos pesos e tenta estimar as variâncias, o que (pelo que entendi) é o mesmo que o RVM faz. Isso é correto?

Percebo que o árbitro mencionou:

http://books.nips.cc/papers/files/nips20/NIPS2007_0976.pdf

não é a implementação que usamos. Eu acho que @vmichel implementou o
Abordagem de bispo, enquanto este artigo propõe uma abordagem de ponto fixo semelhante a
uma abordagem de descida por coordenadas. Este código definitivamente precisa de algum amor ...

Obrigado @agramfort , estava pensando sobre isso. Não entrei em detalhes mas achei que como o papel era a única referência ...

Eu apreciaria muito se você pudesse adicionar um comentário citando o capítulo do bispo que foi usado e talvez dizendo que deveríamos implementar o outro artigo.

(entre as coisas mais lentas no conjunto de testes agora é ajustar ARD no conjunto de dados de Boston nos testes comuns)

Obrigado @agramfort , estava pensando sobre isso. Não entrei em detalhes mas achei que como o papel era a única referência ...

Eu apreciaria muito se você pudesse adicionar um comentário citando o capítulo do bispo que foi usado e talvez dizendo que deveríamos implementar o outro artigo.

consulte: https://github.com/scikit-learn/scikit-learn/pull/1530

Aliás, alguém já se incomodou com o fato de que a seção Linear Generalizada
Os modelos não contêm nenhum modelo generalizado?

Sim: regressões logísticas.

Eu me pergunto se existe um método semelhante para ARD? Isso seria legal como o
a implementação atual do ARD é bastante lenta: - /

Eu acredito que o solucionador rápido mais promissor de ARD é implementar o
estratégia exposta em:
http://books.nips.cc/papers/files/nips20/NIPS2007_0976.pdf

Eu coloquei a essência de um código escrito há um tempo.

Se alguém quiser trabalhar no ARD, achei que poderia ser útil.

https://gist.github.com/4494613

ATENÇÃO: não é muito testado e não garanto correção mas
parece funcionar.

@amueller
Eu analisei ARD em http://books.nips.cc/papers/files/nips20/NIPS2007_0976.pdf e acho que RVM e ARD querem otimizar a mesma função objetivo. A diferença aparece no método usado para otimizar esta função. No RVM, os autores notaram que a maior parte do peso será próximo a zero e eles usaram isso para derivar um algoritmo "rápido".

Isso parece estranho. Se o objetivo for o mesmo, você deve ser capaz de usar os mesmos métodos de otimização, certo?

Sim, com certeza você deveria, mas acho que os autores do RVM usaram uma estratégia de otimização diferente para ter um algoritmo mais rápido e esparso.

@yedtoss Tenho certeza de que há alguma outra diferença. Como eu disse antes, pode ser que o RVM funcione em um espaço de recursos ou com um kernel ou algo assim. Caso contrário, você poderia apenas substituir a implementação do ARD? Isso é regressão, no entanto, e você quer uma classificação, certo?

@agramfort você sabe alguma coisa sobre a diferença entre ARD e RVM?

@amueller
Inicialmente, o RVM é uma técnica de regressão. Mas os autores apresentaram uma maneira de usá-lo para classificação. O RVM usava qualquer tipo de kernel.
O que quero dizer é que a probabilidade logarítmica de ARD (equação 2 de Uma Nova Visão de Determinação de Relevância Automática) e de RVM (equação 7 de Maximização de probabilidade marginal rápida para modelos bayesianos esparsos) são idênticas.

Acho que teria que ler os jornais para saber o que está acontecendo ....

desculpe pessoal eu não sou muito um cara bayesiano ... eu não conheço bem o
sutilezas ...

RVMs são patenteados pela Microsoft.

louco.

@larsmans @amueller embora haja uma patente nos EUA para RVM, o autor recomenda uma implementação GPLv2 Matlab em sua página da web, então eu acho que está ok para implementá-la ...
http://www.miketipping.com/sparsebayes.htm

melhor,
Angelos

A licença e patente tratava de patentes de software. Os direitos que você tem com essa implementação são a interseção dos direitos concedidos pela GPL e aqueles concedidos pelo detentor da patente.

Dito isso, descobri, entretanto, que as máquinas de vetores de suporte são patenteadas pela AT&T, mas a patente aparentemente nunca foi aplicada. Se algo semelhante puder ser comprovado com os RVMs, posso mudar de ideia sobre eles.

@larsmans Eu escrevi um port numpy / python puro de implementação dlib (muito lento no momento, vou tentar citá-lo). De acordo com o cabeçalho, o implem do dlib existe desde 2008 e eles parecem estar bem com ele. Você consideraria mudar de ideia sobre ter RVM no sklearn?

Vamos ouvir a opinião de @GaelVaroquaux sobre isso. O implem dlib não mostra nada, desde que você não possa provar que é amplamente usado sem uma licença de patente.

Há alguma atualização sobre este tópico? Tenho pesquisado RVMs recentemente e gostaria de saber se havia algum código por aí ...

Não creio que alguém tenha tentado uma implementação rápida e ainda não temos certeza sobre o status legal.

@jlopezpena Dê uma olhada no dlib, o código é bastante claro e é apenas o cabeçalho (modelos). Deve ser bastante fácil construir uma extensão C para usar a partir do numpy

Olá a todos,

Recentemente, traduzi o programa SparseBayes MATLAB de Mike Tipping, disponível gratuitamente, que implementa principalmente o RVM, do MATLAB para o Python. Ele pode ser encontrado aqui: https://github.com/jhallock7/SparseBayes-Python . Entrei em contato com Mike Tipping, e ele disse que a patente da Microsoft é apenas para o algoritmo lento original, enquanto o programa SparseBayes usa o mais rápido encontrado aqui: http://www.miketipping.com/papers/met-fastsbl.pdf . Portanto, não haveria problema se alguma forma de seu programa fosse incorporada ao scikit-learn. Eu sou relativamente novo em Python, então minha tradução pode, sem dúvida, ser melhorada ou modificada.

Obrigado por querer contribuir e também por verificar o status da patente.
Porém, há outra questão: se esses algoritmos são amplamente úteis.

Não olhei para o algoritmo e seu uso desde a última vez em que li o livro de Bishop, há algum tempo.
Acho que um exemplo interessante seria mostrar que dá melhor incerteza do que calibrar
um SVM, ou que seja mais rápido (calibrar um SVM e pesquisar em C precisa de muita validação cruzada).

@amueller RVM (principalmente regressão de vetor de revelação (RVR)) é muito útil na análise de dados de neuroimagem. Muitos artigos usam esse método em vez de SVR para fazer previsões. Será perfeito se esse método puder ser adicionado à caixa de ferramentas do scikit learn.

@amueller Implementei a versão lenta do RVM que pode usar EM ou algoritmo de ponto fixo para ajustar o modelo (principalmente para fins de aprendizagem / acadêmicos) e a principal diferença entre RVM e SVR que observei em alguns exemplos é a dispersão, ou seja, o número de 'suporte 'vetores usados ​​na previsão. Em muitos casos, o RVM produz resultados comparáveis ​​ao SVR, com o número de vetores de suporte sendo apenas uma fração do que o SVR usa
( aqui está um exemplo simples que também é usado em Tipping 2001)

@amueller (Adicionando ao comentário anterior) E, obviamente, um pequeno número de vetores de suporte implicará em uma previsão muito rápida.
Outra vantagem do RVM é o tratamento probabilístico. Com RVM para cada ponto de dados no conjunto de teste, você encontra não apenas estimativa pontual, mas também distribuição preditiva

o RVR também fornece distribuições de probabilidade?

Parece que RVR e RVM são candidatos razoáveis ​​para inclusão. Não tenho certeza sobre os algoritmos de última geração, no entanto. É http://www.miketipping.com/papers/met-fastsbl.pdf ? Isso parece muito antigo. O estilo de codificação SparseBayes é ... interessante, e acho que serviria melhor como referência do que como base para a implementação do sklearn.

Sim, o RVR fornece distribuições de probabilidade, no entanto, em alguns casos, a variação da distribuição preditiva pode ser menor para pontos de dados fora do domínio do exemplo de conjunto de treinamento.
Pelo que sei, o paper que você mencionou é a última versão do RVM, ela também corresponde à implementação do Matlab no site do Tipping (versão 2).

Eu também encontrei uma comparação interessante de velocidade de RVM e SVM no livro de Kevin Murphy:
"O RVM também é mais rápido de treinar. Isso apesar do código RVM estar em Matlab e o código SVM estar em C" (Capítulo 14, p.490). No entanto, parece que eles fizeram comparações apenas para pequenos conjuntos de dados.

@amueller RVM (principalmente regressão de vetor de revelação (RVR)) é muito útil em
análise de dados de neuroimagem.

Não estou convencido (e faço neuroimagem). Eu não vi um bom
comparação empírica.

Eu vejo que o caminho a seguir é ter RVMs em um pacote separado, com
API scikit-learn e incentive um bom trabalho empírico para mostrar seus
utilidade. Se eles forem úteis, mescle-os no scikit-learn.

Alguns estudos de neuroimagem têm usado a regressão do vetor de relevância (RVR) e
fez comparações entre RVR e SVR.
Para listar alguns:
http://www.sciencedirect.com/science/article/pii/S1053811910000108
http://www.sciencedirect.com/science/article/pii/S1053811910012644
http://www.sciencedirect.com/science/article/pii/S1053811910003459
http://www.nature.com/npp/journal/v39/n3/abs/npp2013251a.html

E, o RVR é implementado em uma caixa de ferramentas de reconhecimento de padrões para
dados de neuroimagem:
http://www.mlnl.cs.ucl.ac.uk/pronto/

Espero que o RVR possa ser incorporado ao scikit-learn.

Muitas felicidades

Zaixu

Na quinta-feira, 15 de outubro de 2015 às 12h57, Gael Varoquaux [email protected]
escreveu:

@amueller RVM (principalmente regressão de vetor de revelação (RVR)) é bonito
útil em
análise de dados de neuroimagem.

Não estou convencido (e faço neuroimagem). Eu não vi um bom
comparação empírica.

Eu vejo que o caminho a seguir é ter RVMs em um pacote separado, com
API scikit-learn e incentive um bom trabalho empírico para mostrar seus
utilidade. Se eles forem úteis, mescle-os no scikit-learn.

-
Responda a este e-mail diretamente ou visualize-o no GitHub
https://github.com/scikit-learn/scikit-learn/issues/1513#issuecomment -148281784
.

Vejo que o caminho a seguir é ter RVMs em um pacote separado, com API scikit-learn, e encorajar um bom trabalho empírico para mostrar sua utilidade. Se eles forem úteis, mescle-os no scikit-learn.

+1

Quer dizer, há https://github.com/AmazaspShumik/Bayesian-Regression-Methods/blob/master/Relevance%20Vector%20Machine%20%26%20ARD/rvm.py que parece relativamente compatível. precisa de set_params e get_params ou herdar de BaseEstimator .

E há https://github.com/jhallock7/SparseBayes-Python que pode ser embrulhado.

@ZaixuCui, por que você deseja que ele esteja no scikit-learn quando existe uma implementação pronta para usar?

Eu tendo a concordar com @GaelVaroquaux e @mblondel . Se ninguém publicou sobre algoritmos em quase dez anos, as pessoas não parecem estar muito interessadas. [oh, o algoritmo padrão é de 2003 até. mas, novamente, libsvm é 2005]

Porque eu uso o scikit, aprenda a fazer SVR, elastic-net.
Então, se houver uma implementação RVR, não vou precisar usar matlab quando
fazer análises de aprendizado de máquina.

Muito obrigado.
Te deseja tudo de bom

Zaixu

Na quinta-feira, 15 de outubro de 2015 às 11h13, Andreas Mueller [email protected]
escreveu:

Quero dizer, existe
https://github.com/AmazaspShumik/Bayesian-Regression-Methods/blob/master/Relevance%20Vector%20Machine%20%26%20ARD/rvm.py
que parece relativamente compatível. precisa de set_params e get_params ou
herdando de BaseEstimator.

E há https://github.com/jhallock7/SparseBayes-Python que poderia
ser embrulhado.

@ZaixuCui https://github.com/ZaixuCui por que você quer que ele esteja em
scikit-learn quando houver uma implementação pronta para usar?

Eu tendo a concordar com @GaelVaroquaux https://github.com/GaelVaroquaux
e @mblondel https://github.com/mblondel . Se ninguém publicou em
algoritmos em quase dez anos, as pessoas não parecem estar muito interessadas.

-
Responda a este e-mail diretamente ou visualize-o no GitHub
https://github.com/scikit-learn/scikit-learn/issues/1513#issuecomment -148440665
.

Porque eu uso o scikit, aprenda a fazer SVR, elastic-net.
Então, se houver uma implementação RVR, não vou precisar usar matlab quando
fazer análises de aprendizado de máquina.

Você pode usar o código Python fazendo RVR que apontamos no
discussão.

Ok obrigado

Na segunda-feira, 19 de outubro de 2015 às 8h29, Gael Varoquaux [email protected]
escreveu:

Porque eu uso o scikit, aprenda a fazer SVR, elastic-net.
Então, se houver uma implementação RVR, não vou precisar usar matlab
quando
fazer análises de aprendizado de máquina.

Você pode usar o código Python fazendo RVR que apontamos no
discussão.

-
Responda a este e-mail diretamente ou visualize-o no GitHub
https://github.com/scikit-learn/scikit-learn/issues/1513#issuecomment -149213151
.

Não poderíamos implementar isso como uma classe muito leve com base em nossa nova implementação do Processo Gaussiano? Tanto quanto eu entendo, RVR é apenas o nome dado a um GP com um tipo especial de kernel.

Embora isso requeira apenas um esforço mínimo, basear a implementação do RVR no GP pode não ser a coisa mais apropriada a se fazer. CC: @jmetzen

@amueller @GaelVaroquaux @ZaixuCui @yedtoss @jlopezpena

Olá, implementei a versão rápida da Relevance Vector Machine com a API scikit-learn,
portanto, se alguém tiver a intenção de usá-lo, fique à vontade para fazê-lo.

Código: https://github.com/AmazaspShumik/sklearn_bayes/blob/master/sklearn_bayes/rvm/fast_rvm.py

Exemplos: https://github.com/AmazaspShumik/sklearn_bayes/blob/master/ipython_notebooks_tutorials/rvm_ard/rvm_demo.ipynb

Existem quatro classes implementadas no código:
-RegressionARD
-ClassificationARD
-RVC
-RVR

Então pode ser RegressionARD e ClassificationARD pode ser útil também

@AmazaspShumik muito obrigado por sua implementação. Bom trabalho: +1:

@AmazaspShumik

Muito obrigado por seus esforços.
Com certeza vou experimentar este pacote.

Desejo-lhes tudo de bom.

Zaixu

Alguém teve problemas para implementar o método @AmazaspShumik predict_proba?

qualquer um aqui tem biblioteca para RVM no php? eu não entendo com RVm pode explicar para mim?

qualquer um tem biblioteca RVM para PHP?

RVMs são patenteados pela Microsoft.

A patente será expirada em breve

04/09/2019
Vencimento antecipado

Alguns links de discussão apontados para a implementação do @AmazaspShumik estão quebrados, basta colocá-los aqui para as pessoas interessadas em (e algumas outras implementações):

https://github.com/AmazaspShumik/sklearn_bayes - RVM + alguma outra implementação de algs
https://github.com/JamesRitchie/scikit-rvm - implementações simples usando scipy
https://github.com/siavashserver/neonrvm - implementação C com ligação Python

Além disso, aqui está a coleção de documentos relevantes:
http://www.miketipping.com/sparsebayes.htm

Há uma implementação C ++ do RVM lá (material suplementar de um artigo):
https://pubs.acs.org/doi/abs/10.1021/ci200128w
Precisamente aqui:
https://pubs.acs.org/doi/suppl/10.1021/ci200128w/suppl_file/ci200128w_si_001.zip

A patente da Microsoft expirou. Poderíamos possivelmente adicioná-lo ao sklearn?

Ele limpa facilmente os requisitos padrão, então não vejo por que não. Talvez seja interessante ter alguns exemplos bons / convincentes. scikit-rvm e sklearn_bayes parecem sem manutenção, mas ainda podem ser úteis.
Provavelmente precisa de um campeão agora que realmente queira trabalhar.

No livro de Murphy, ele afirma que o desempenho dos RVMs é muito semelhante ao dos SVMs, mas tem a vantagem de ser um método probabilístico verdadeiro, de modo que fornece probabilidades calibradas como respostas. Aqui https://github.com/probml/pmtk3/blob/master/docs/tutorial/html/tutKernelClassif.html ele comparou os métodos usando um pequeno conjunto de dados

Você pode fornecer um link para a versão renderizada?
Além disso, não é surpreendente que esteja em um pequeno conjunto de dados, visto que é provável que tenha problemas de escalabilidade.

@amueller http://htmlpreview.github.io/?https : //github.com/probml/pmtk3/blob/master/docs/tutorial/html/tutKernelClassif.html

Vou tentar trabalhar na implementação. Qualquer ajuda seria muito apreciada.

IIRC, uma vantagem do RVM sobre o SVM, é que você pode encontrar o parâmetro C ideal sem fazer uma passagem de otimização.
Eu me pergunto se o autor original estaria disposto a contribuir com sua implementação de referência.
Bem, está no Matlab e o Mike Tipping nem está no github ...

Olá @amueller e pessoal! Vimos esse tópico e decidimos implementar uma versão compatível com sklearn do RVM (https://github.com/Mind-the-Pineapple/sklearn-rvm). Baseamos muito do que fizemos na implementação da JamesRitchie. Seria ótimo se alguém estivesse disposto a dar uma olhada nisso e feedbacks e contribuições (@themrzmaster) são bem-vindos :)
Temos planos de manter este repo, implementando a versão rápida na versão 0.2 e esperamos que talvez algum dia este código possa ser útil para o repositório principal do scikit-learn 😊 🍍

Olá @amueller e pessoal! Vimos esse tópico e decidimos implementar uma versão compatível com sklearn do RVM (https://github.com/Mind-the-Pineapple/sklearn-rvm). Baseamos muito do que fizemos na implementação da JamesRitchie. Seria ótimo se alguém estivesse disposto a dar uma olhada nisso e feedbacks e contribuições (@themrzmaster) são bem-vindos :)
Temos planos de manter este repo, implementando a versão rápida na versão 0.2 e esperamos que talvez algum dia este código possa ser útil para o repositório principal do scikit-learn 😊 🍍

Olá @PedroFerreiradaCosta
Eu testei esta api scikit-learn e parece que ainda está muito lenta (parece não estar respondendo ainda). Você acha que o motivo pode ser ele está implementado no Windows? Abaixo está o que eu usei:
EMRVC (kernel = 'rbf', gamma = 'scale', n_iter_posterior = 10, max_iter = 500, compute_score = True, verbose = True) Obrigado por sua resposta @themrzmaster @PedroFerreiradaCosta

Olá @mustuner ! Obrigado por experimentar nossa API!
O RVM tem uma complexidade computacional maior do que, por exemplo, o SVM (O (M ^ 3)), o que pode torná-lo mais lento para os casos em que você tem um grande número de funções básicas. De qualquer maneira, há uma série de coisas que você pode fazer para acelerar o processo. Você pode pré-computar a matriz do kernel e alimentá-la para nosso algoritmo em vez de X, (definir kernel = 'pré-computado') ou você também pode diminuir a escala do alpha_threshold (definido por padrão em 1e5). Lembre-se de que esta segunda opção pode levar a uma menor precisão do modelo.
Espero que isto ajude! E fique à vontade para abrir um problema para que possamos ajudar mais.

melhor,
Pedro

Olá @mustuner ! Obrigado por experimentar nossa API!
O RVM tem uma complexidade computacional maior do que, por exemplo, o SVM (O (M ^ 3)), o que pode torná-lo mais lento para os casos em que você tem um grande número de funções básicas. De qualquer maneira, há uma série de coisas que você pode fazer para acelerar o processo. Você pode pré-computar a matriz do kernel e alimentá-la para nosso algoritmo em vez de X, (definir kernel = 'pré-computado') ou você também pode diminuir a escala do alpha_threshold (definido por padrão em 1e5). Lembre-se de que esta segunda opção pode levar a uma menor precisão do modelo.
Espero que isto ajude! E fique à vontade para abrir um problema para que possamos ajudar mais.

melhor,
Pedro

Obrigado @PedroFerreiradaCosta Deixe-me tentar isso