Ciência de dados: criando uma solução estocástica com máquina de vetores de suporte em python
Support Vector Machine (SVM) algoritmos de aprendizagem de máquina são uma ferramenta fantástica para um cientista de dados para usar com Python. É claro que, mesmo as melhores soluções têm problemas. Por exemplo, você pode pensar que o SVM tem muitos parâmetros no SVM. Certamente, os parâmetros são um incômodo, especialmente quando você tem que testar tantas combinações dos mesmos, o que pode levar muito tempo da CPU.
Conteúdo
No entanto, o principal problema é o tempo necessário para a formação do SVM. Você deve ter notado que os exemplos usam pequenos conjuntos de dados com um número limitado de variáveis, e executar algumas extensas pesquisas grade ainda leva muito tempo. conjuntos de dados do mundo real são muito maiores. Às vezes pode parecer que leva uma eternidade para treinar e otimizar seu SVM no seu computador.
Uma solução possível quando você tem muitos casos (um limite sugerido é de 10.000 exemplos) é encontrado dentro do mesmo módulo SVM, o LinearSVC classe. Este algoritmo funciona apenas com o kernel linear e seu foco é classificar (desculpe, não regressão) um grande número de exemplos e variáveis a uma velocidade maior do que o SVC standard. Tais características tornam o LinearSVC um bom candidato para a classificação à base textual. LinearSVC tem menos e ligeiramente diferentes parâmetros de resolver do que o SVM usual (que é semelhante a uma classe de regressão):
C: O parâmetro de penalidade. Pequenos valores implicam mais de regularização (modelos mais simples com atenuada ou definir a zero coeficientes).
perda: Um valor de L1 (Tal como em SVM) ou l2 (Peso mais erros, por isso se esforça mais difícil para caber exemplos erroneamente classificados).
Video: Curso MySQL #03 - Criando o primeiro Banco de Dados
pena: Um valor de l2 (Atenuação de parâmetros menos importantes) ou L1 (Sem importância parâmetros são ajustados a zero).
dual: Um valor de verdade ou falso. Refere-se ao tipo de problema de otimização resolvido e, embora isso não vai mudar o placar obtido muito, definindo o parâmetro para falso resulta em cálculos mais rápidos do que quando ele está definido para verdade.
Video: Criando classes DAO e Model para recuperar do Banco de Dados
o perda, pena, e dual parâmetros também estão vinculados por restrições recíprocas, portanto, consulte abaixo para planejar qual a combinação de usar com antecedência.
| pena | perda | dual |
|---|---|---|
| L1 | l2 | Falso |
| l2 | L1 | Verdade |
| l2 | l2 | Verdadeiro falso |
O algoritmo não suporta a combinação de pena =‘L1’ e perda =‘L1’. No entanto, a combinação de pena =‘l2’ e perda =‘L1’ perfeitamente replica a abordagem de otimização SVC.
Video: Aulas Python - 151 - Bancos de Dados V - MySQL
LinearSVC é bastante rápido, e um teste de velocidade contra SVC demonstra o nível de melhoria que esperar na escolha deste algoritmo.
de sklearn.datasets importar make_classificationX, y = make_classification (N_SAMPLES = 10 ** 4, n_features = 15, n_informative = 10, random_state = 101) X_train, X_test, y_train, y_test = train_test_split (X, Y, test_size = 0,3, random_state = 101) a partir sklearn.svm importação SVC, LinearSVCslow_SVM = SVC (kernel = “linear”, random_state = 101) fast_SVM = LinearSVC (random_state = 101, penalty = `l2`, perda = `L1`) slow_SVM.fit (X_train, y_train ) fast_SVM.fit (X_train, y_train) print `SVC pontuação precisão do teste:% 0.3f` % slow_SVM.score (X_test, y_test) print `test LinearSVC pontuação precisão:% 0.3f` % fast_SVM.score (X_test, y_test) SVC teste pontuação precisão: 0.808LinearSVC pontuação precisão do teste: 0,808
Depois de criar um conjunto de dados artificial usando make_classfication, o código obtém a confirmação de como os dois algoritmos chegar a resultados idênticos. Neste ponto, o código testa a velocidade das duas soluções no conjunto de dados sintéticos, a fim de entender como eles escalar a usar mais dados.
importação timeitX, y = make_classification (N_SAMPLES = 10 ** 4, n_features = 15, n_informative = 10, random_state = 101) de impressão ‘segs avg para SVC, melhor de 3:% 0.1f’
% Np.mean (timeit.timeit ( “slow_SVM.fit (X, Y)”, “de importação __main__ slow_SVM, X, Y”, número = 1)) de impressão `segs avg para LinearSVC, melhor de 3:% 0.1f `% np.mean (timeit.timeit ( ‘fast_SVM.fit (X, Y)’, “a partir __main__ fast_SVM importação,
X, Y”, número = 1))
O sistema de exemplo mostra o seguinte resultado:
segundos para o SVC avg, melhor de 3: segs 15.9avg para LinearSVC, melhor de 3: 0,4
É evidente que, dada a mesma quantidade de dados, LinearSVC é muito mais rápido do que SVC. Você pode calcular seu índice de desempenho como 15,9 / 0,4 = 39,75 vezes mais rápido que SVC. Mas e se você aumentar o tamanho da amostra de 10 ** 4 a 10 ** 5?
segundos para o SVC avg, melhor de 3: segs 3831.6avg para LinearSVC, melhor de 3: 10,0
Os resultados são bastante impressionantes. LinearSVC é 383.16 vezes mais rápido do que SVC. Mesmo se LinearSVC é bastante rápido na realização de tarefas, você pode precisar para classificar ou regredir com exemplos na faixa de milhões. Você precisa saber se LinearSVC ainda é uma escolha melhor.
Você já viu como o SGD classe, usando SGDClassifier e SGDRegressor, ajuda a implementar um algoritmo do tipo SVM em situações com milhões de linhas de dados sem investir muito poder computacional. Tudo que você tem a fazer é definir a sua perda para ‘dobradiça’ para SGDClassifier e para ‘epsilon_insensitive’ para SGDRegressor.
Um outro teste de desempenho e de velocidade faz com que as vantagens e limitações do uso LinearSVC ou SGDClassifier Claro:
de sklearn.linear_model SGDClassifierX importação, y = make_classification (N_SAMPLES = 10 ** 6, n_features = 15, n_informative = 10, random_state = 101) X_train, X_test, y_train, y_test = train_test_split (X, Y, test_size = 0,3, random_state = 101)
A amostra é bastante grande - 1 milhão de casos. Se você tem memória suficiente e um monte de tempo, você pode até querer aumentar o número de casos treinados ou o número de recursos e mais extensivamente testar como os dois algoritmos escala com dados grandes.
fast_SVM = LinearSVC (random_state = 101) fast_SVM.fit (X_train, y_train) print `LinearSVC pontuação precisão do teste:% 0.3f` % fast_SVM.score (X_test, y_test) print `segundos AVG para LinearSVC, melhor de 3:% 0.1f `% np.mean (timeit.timeit ( ‘fast_SVM.fit (X_train, y_train)’, ‘de importação __main__ fast_SVM, X_train, y_train’, número = 1)) LinearSVC precisão teste pontuação: segs 0.806avg para LinearSVC, de melhores 3: 311.2
No computador de teste, LinearSVC completou seus cálculos sobre 1 milhão de linhas em cerca de cinco minutos. SGDClassifier em vez levou cerca de um segundo para processar os mesmos dados e obter uma inferior, mas comparável, pontuação.
Video: SQL Azure - Conectando e administrando um banco de dados na nuvem
stochastic_SVM = SGDClassifier (perda = `dobradiça`, n_iter = 5, aleatório = True, random_state = 101) stochastic_SVM.fit (X_train, y_train) print `test SGDClassifier pontuação precisão:% 0.3f` % stochastic_SVM.score (X_test, y_test) print `segundos AVG para SGDClassifier, melhor de 3:% 0.1f` % np.mean (timeit.timeit ( “stochastic_SVM.fit (X_train, y_train)”, “a partir __main__ stochastic_SVM importação, X_train, y_train”, number = 1) ) a precisão do teste SGDClassifier pontuação: seg 0.799avg para SGDClassifier, melhor de 3: 0,8
Aumentar o n_iter parâmetro pode melhorar o desempenho, mas proporcionalmente aumenta o tempo de computação. Aumentar o número de iterações até um determinado valor aumenta o desempenho. No entanto, após esse valor, o desempenho começa a diminuir por causa da overfitting.