Classificar e estimar com svm para aprendizado de máquina

Como um exemplo de como você pode usar um SVM para resolver um problema complexo para aprendizado de máquina, aqui você encontra uma demonstração de uma tarefa de reconhecimento de escrita à mão e como resolvê-lo usando um kernel não-linear, a RBF. O algoritmo SVM aprende com o conjunto de dados dígitos disponíveis a partir dos conjuntos de dados do módulo no pacote scikit-learn. O conjunto de dados dígitos contém uma série de imagens de pixel de 8 x 8 em tons de cinza de números escritos à mão que variam de 0 a 9.

O problema é bastante simples quando comparado a muitos problemas que os motores de reconhecimento de imagem resolver hoje, mas ele ajuda a compreender o potencial da abordagem de aprendizagem. Mesmo que o exemplo se baseia em Python, você poderia criar um exemplo semelhante usando R, porque ambas as línguas contam com a mesma biblioteca LIBSVM trabalhando nos bastidores. O exemplo de saída aparece abaixo.

matplotlib.pyplot importação como plt

matplotlib importação como MPL

de load_digits sklearn.datasets importação

importar numpy como np

importação aleatória

dígitos = load_digits ()

X, Y = digits.data, digits.target

% Matplotlib embutido

random_examples = [random.randint (0, LEN (digits.images))

para i no intervalo (10)]

para n, em número Enumerar (random_examples):

plt.subplot (2, 5, n + 1)

plt.imshow (digits.images [número], cmap = `binário`,

interpolação = `nenhuma`, medida = [0,8,0,8])

plt.grid ()

plt.show ()

O código de exemplo imprime aleatoriamente algumas amostras para que você pode ver um exemplo dos diferentes estilos manuscritas encontradas no conjunto de dados. Seus exemplos impressos podem ser diferentes. O código processa a informação gráfica a partir de uma série de números, colocado em um vetor, cada um apontando para um pixel da imagem. O algoritmo aprende que, se certas pixels ativar juntos, a imagem representada corresponde a um número particular.

Este exemplo demonstra a ideia defendida pela tribo Analogizers: Certos padrões correspondem a respostas com base em uma analogia. SVMs tendem a esconder esse fato porque eles parecem fornecer uma combinação linear de características ponderadas, assim como regressão linear faz, mas lembrar que ao aplicar as funções do kernel, a otimização é baseada nos produtos de ponto de exemplos.

produtos de ponto são uma maneira de estimar a distância entre os pontos, a fim de dividir o espaço de características em partições homogêneos com a mesma classe dentro. Distância é uma maneira de estabelecer semelhanças em um espaço feito de recursos. Então SVMs trabalha na similaridade, associando pontos e padrões com base na distância.

Para verificar os resultados do modelo corretamente, você primeiro extrair 30 por cento dos exemplos para usar como um conjunto de teste (um out-of-sample). Você também quer preparar as características por rescaling-los na faixa de -1 a +1 para facilitar os cálculos SVM. O algoritmo primeiro aprende os parâmetros de transformação do conjunto de treinamento sozinho e só depois que eles são aplicados ao conjunto de teste para que você evite qualquer tipo de vazamento de informações fora de amostra.

Uma acção crítica para tomar antes de alimentar os dados para um SVM é dimensionamento. Scaling transforma todos os valores para o intervalo entre -1 a 1 (ou 0-1, se você preferir). Dimensionamento transformação evita o problema de ter algumas variáveis ​​influenciam o algoritmo e faz os cálculos exata, suave e rápido.

O código começa por adotar uma SVM com um kernel não-linear. Para verificar a utilidade da representação pelo algoritmo de aprendizado de máquina, o exemplo usa a pontuação precisão (a porcentagem de acerto) como uma medida de quão bem o modelo é).

de sklearn.cross_validation train_test_split importação

de sklearn.cross_validation cross_val_score importação

de sklearn.preprocessing MinMaxScaler importação

# Mantemos 30% exemplos aleatórios para teste

Video: Lecture 14 - Support Vector Machines

X_train, X_test, y_train, y_test = train_test_split (X,

y, test_size = 0,3, random_state = 101)

# Nós escalar os dados no intervalo [-1,1]

escala = MinMaxScaler (feature_range = (- 1, 1)). encaixar (X_train)

X_train = scaling.transform (X_train)

X_test = scaling.transform (X_test)

de importação sklearn.svm SVC

SVM = SVC ()

cv_performance = cross_val_score (SVM, X_train, y_train,

CV = 10)

test_performance = svm.fit (X_train, y_train) .score (X_test,

y_test)

print ( `precisão Validação cruzada marcar:% 0.3f`

`Precisão do teste marcar:% 0.3f`

% (Np.mean (cv_performance), test_performance))

Validação cruzada pontuação precisão: 0,981,

teste pontuação precisão: 0,985

Depois de ter verificado marcar a validação cruzada usando as hiper-parâmetros padrão, o código usa uma busca sistemática para procurar melhores definições que poderiam fornecer um maior número de respostas exatas. Durante a busca, o código testa combinações diferentes de linear e RBF juntamente com C e gama parâmetros. (Este exemplo pode exigir muito tempo para ser executado.)

de GridSearchCV importação sklearn.grid_search

importar numpy como np

learning_algo = SVC (kernel = `linear`, random_state = 101)

search_space = [{ `Kernel`: [ `linear`],

`C`: np.logspace (-3, 3, 7)},

{ `Kernel`: [ `RBF`],

`C`: np.logspace (-3, 3, 7),

`Gama`: np.logspace (-3, 2, 6)}]

gridsearch = GridSearchCV (learning_algo,

param_grid = search_space,

reequipamento = True, CV = 10)

gridsearch.fit (X_train, y_train)

print ( `Melhor parâmetro:% s`

% Str (gridsearch.best_params_))

cv_performance = gridsearch.best_score_

test_performance = gridsearch.score (X_test, y_test)

print ( `precisão Validação cruzada marcar:% 0.3f`

`Precisão do teste marcar:% 0.3f`

% (Cv_performance, test_performance))

Melhor parâmetro: { `núcleo`: `RBF`, `C`: 1,0,

`Gama`:} ,10000000000000001

Validação cruzada pontuação precisão: 0,988,

teste pontuação precisão: 0,987

Os cálculos podem demorar alguns minutos, após o qual o computador informa o melhor núcleo, C, e gama parâmetros, juntamente com um currículo melhorado pontuação atingindo quase 99 por cento de precisão. A precisão é alta, indicando que o computador pode quase distinguir todas as diferentes maneiras de escrever números de 0 a 9. Como resultado final, o código imprime os números que o SVM erroneamente previstos no conjunto de teste.

predição = gridsearch.predict (X_test)

Video: Aprendizado de Máquina #1 - Representação de Modelos (Matlab)

wrong_prediction = (previsão! = y_test)

test_digits = scaling.inverse_transform (X_test)

para n, (número, YP, YT) em enumerar (ZIP (

scaling.inverse_transform (X_test) [wrong_prediction],

predição [wrong_prediction],

y_test [wrong_prediction])):

plt.subplot (2, 5, n + 1)

plt.imshow (number.reshape ((8,8)), cmap = `binário`,

interpolação = `nenhuma`,

medida = [0,8,0,8])

plt.title ( `pred:` + str (yp) +"! ="+ Str (YT))

plt.grid ()

plt.show ()

Os números que o algoritmo errou são particularmente difíceis de adivinhar, e não é de admirar que ele não poderia levá-los bem. Lembre-se também que o conjunto de dados fornecido pelo scikit-learn é apenas uma parte do real dataset MNIST. O conjunto de dados completo consiste de 60.000 exemplos de treinamento e 10.000 exemplos de teste. Usando o mesmo algoritmo SVC e as mesmas configurações, o SVC pode aprender o conjunto de dados original, permitindo que o computador para ler qualquer número escrito à mão que você apresenta.