Scikit Learn Tutorial
Procedimento
Neste tutorial, vamos aprender sobre a Biblioteca Scikit Learn of Python e como podemos usar essa biblioteca para desenvolver vários algoritmos de aprendizado de máquina. Este guia incluirá o seguinte conteúdo que será discutido um por um com uma explicação detalhada:
- Instalação
- Plotagem de gráfico
- Vários conjuntos de dados e seus utilitários no Scikit aprendem
- Seleção de recursos
- Treinamento de um modelo de aprendizado de máquina
Etapa 01: Instalação
Antes de começar com o Scikit Learn, precisamos primeiro instalar seu pacote nos repositórios Python. Para fazer isso, somos obrigados a ter Python (a versão mais recente ou qualquer outra) baixada e instalada em nosso sistema. Para baixar o Python no seu sistema, navegue até o link I.e.
“Https: // www. Pitão .org “. Depois de redirecionado para este URL, vá para downloads e clique no Python com qualquer versão que você deseja baixar como abaixo:
Depois que o python é baixado, agora precisamos instalá -lo. Selecione a opção de instalação personalizada após adicionar o python ao caminho.
Verifique todas as opções na janela Popping para instalar os pacotes de pip com python e continue e selecione o próximo.
A próxima etapa será especificar o local para os pacotes Python, verificar todas as opções avançadas fornecidas, especificar o local e clique em Instalar; Isso começará o processo de instalação que continuará por um tempo.
Agora o Python está sendo instalado em nossos sistemas. Para abrir o tipo de shell python, coloque Python no menu de pesquisa e pressione Enter. A concha Python então abrirá. Agora avançaremos para instalar o Scikit Learn on Python. Para isso, abra o prompt de comando e digite Python para verificar se o Python está funcionando no sistema ou não. Se o sistema retornar a versão do Python, isso significa que o python está funcionando corretamente. Em seguida, precisamos verificar a versão do PIP para atualizar os pacotes do PIP:
$ python
$ PIP -Versão
Depois de verificar as versões Python e Pip, agora digite o seguinte comando no prompt de comando para instalar o Scikit Learn on Python.
$ pip install scikit aprender
Depois disso, o Scikit com todos os seus pacotes começará a instalar.
Agora, o Scikit Learn foi instalado em nosso sistema e agora podemos usar os pacotes Scikit para desenvolver qualquer algoritmo de aprendizado de máquina. Após a instalação bem -sucedida do Scikit, agora avançaremos para a próxima etapa, onde saberemos como plotar os gráficos dos dados usando o Scikit Learn.
Etapa 02: plotagem de gráfico
Os gráficos são conhecidos como ferramentas visuais que ajudam a visualizar as informações fornecidas se os dados nos conjuntos de dados forem numerosos ou complicados o suficiente para descrever. Os gráficos enfatizam representar a relação entre uma ou muitas variáveis. Para trabalhar com os algoritmos de aprendizado de máquina, precisamos conhecer a representação de dados para a análise de dados para treinar e testar os dados de acordo. O Scikit Learn fornece muitos desses pacotes de visualização (em forma gráfica) para os vários conjuntos de dados.
Exemplo# 01
A visualização dos dados na forma de um gráfico pode ser obtida usando o pacote matplotlib. Matplotlib é um pacote Python que contribui como a base do Sci-Kit Learn Plotting Packages. O Scikit Learn se integra ao Matplotlib para plotagem (representação visual dos dados ou os resultados alcançados após o treinamento e o teste dos dados em algoritmos de aprendizado de máquina). Vamos tentar implementar um exemplo usando o matplotlib.
Suponha que queremos traçar alguns números aleatórios para visualizar seu relacionamento entre si. Podemos levar esses números aleatoriamente, e.g., 0.5, 1.5, 2.5. Para escrever o código, importaremos a biblioteca Matplotlib dos pacotes Python como PLT. Após esta etapa, agora podemos usar o PLT em vez de escrever Matplotlib em todo o código. Em seguida, usando este PLT, escreveremos um comando para plotar os números que já selecionamos aleatoriamente usando a função “PLT. plotagem ("números selecionados") ". Para exibir esses números no gráfico na saída, usaremos a função “PLT. mostrar()". O código pode ser criado de uma maneira subsequente:
$ import matplotlib. pyplot como plt
$ plt. Lote ([0.5, 1.5, 2.5])
$ plt. mostrar()
Os números serão exibidos na saída no gráfico:
Exemplo# 02
Se queremos plotar os dados na forma de um gráfico de dispersão, podemos usar a função “dispersão. trama ()". O gráfico de dispersão representa os dados na forma dos pontos de dados dos pontos. Essas parcelas funcionam em duas ou mais duas variáveis. Cada ponto ou ponto de dados no gráfico representa os dois valores diferentes (cada um no eixo x e no eixo y) correspondentes a um ponto de dados em um conjunto de dados.
No exemplo subsequente, planejaremos um gráfico de dispersão. Para fazer isso, vamos importar o matplotlib PyPlot como PLT. Este PLT pode então ser usado no lugar de Matplotlib. Pyplot. Depois disso, definiremos as duas variáveis x e y como x = 1, 3, 5, 7 e y = 2, 4, 6, 8, 8. Para o enredo de dispersão, a dimensão de x e y precisa ser correspondente. Para plotar as duas variáveis, usaremos a função PLT. dispersão ("variável 1, variável 2"). Para exibir essas variáveis no gráfico, use a função PLT. mostrar ().
$ import matplotlib. pyplot como plt
$ x = [1, 3, 5, 7]
$ y = [2, 4, 6, 8]
$ plt. dispersão (x, y)
$ plt. mostrar ()
A relação entre as duas variáveis especificadas na forma de uma trama dispersa será exibida como:
Os exemplos acima mencionados podem ser usados para plotar os dados específicos e saber sobre seu relacionamento entre si.
Exemplo# 03
Agora, vamos supor que estávamos trabalhando com algum conjunto de dados binários, e temos que classificar os dados como pertencentes à classe 0 ou classe 1. Desenvolvemos um classificador binário para esses dados usando um algoritmo de aprendizado de máquina e agora queremos saber o quão bem esse classificador está funcionando. Para esse fim, podemos usar um AUC-ROC_CURVE.
Na curva AUC -RUC, a AUC informa qual grau o classificador desenvolvido pode prever as classes corretamente, como 0 ou 1, e o ROC mostra a probabilidade dos classificadores que representam as classes corretamente. Curva AUC-RUC_ exibe a curva entre FPR (eixo y) e TPR (eixo x), que são ambos ND-Arrays. Para implementar essa curva AUC-RUC, primeiro, importe o MatplotLibpyPlot como PLT para que possamos chamar o PLT para plotar.
Em seguida, importaremos o Numpy como NP para criar os ND-Arrays. Após essa importação de métricas Sklearn. Agora vamos especificar o X e Y usando o NP. Array () para criar os ND-Arrays. ND-Arrays usam o Numpy para armazenar os números seqüenciais neles. Para especificar o FPR e TPR e os limites, usaremos o método “Métricas.roc_curve (x, y) ”e depois usaremos esses valores de FPR e TPR para armazenar no ROC_AUC chamando a função de“ métricas.AUC () ”.
Depois que esses valores forem especificados, chamaremos a função usando “métricas. Roccurvedisplay () ”ao passar FPR, TPR e ROC_AUC em seus argumentos e armazená -los em variável exibir todos. Então vamos chamar a função. plot () e PLT. Mostrar () para exibir a curva ROC-AUC com os parâmetros especificados na saída da seguinte forma:
Depois de executar o código acima mencionado, obtemos a seguinte saída:
A curva RUC-AUC foi exibida na saída agora, o que representa o quanto nosso classificador desenvolvido previu as classes como 1 ou 0 corretamente. A curva ROC-AUC funciona para os conjuntos de dados com classificação binária.
Exemplo # 04
Outro método de plotagem de gráfico usando o Scikit Aprenda a curva de calibração. A curva de calibração tem outro nome: o diagrama de confiabilidade; Essa curva traça a média de probabilidade prevista contra a classe positiva no eixo y da curva, recebendo a entrada do classificador de classificação binária. Para implementar essa curva de calibração, vamos resolver um exemplo em que iremos importar primeiro o conjunto de dados "Faça a classificação" do pacote Sklearn DataSets, depois importaremos o trem e a divisão de teste da seleção do modelo Sklearn e, em seguida, usando a regressão logística de importação de seleção linear Sklearn e a regressão logística e Após essa curva de calibração de importação e exibição das “calibrações Sklearn”.
Depois de importarmos todos os pacotes importantes e necessários, agora carregue o método "Faça a classificação" usando o método "DataSet_Name ()", depois disso dividiremos os dados para fins de trem e teste usando o método “Train_test__split ()”, então nós então nós construirá o modelo de classificação usando "LogisticRegression ()" e ajustará esse modelo em x_train e y_train.
Agora, usando os rótulos e probabilidades que foram previstas usando “classificador. prever probabilidade () ”ignorando o mais XTE como seu argumento de entrada, chame o método“ Curve de calibração () “para plotar a curva de calibração primeiro e depois exibi -lo usando“ DisplayCurve () ”.
A saída exibe a plotagem da curva de calibração que usou as verdadeiras probabilidades previstas de um classificador binário.
Etapa 03: Vários conjuntos de dados e seus utilitários no Scikit Learn
Para trabalhar com algoritmos de aprendizado de máquina, precisamos ter os conjuntos de dados que podemos usar para criar os algoritmos específicos e alcançar as saídas desejadas. O Scikit Learn vem com alguns pacotes que possuem conjuntos de dados incorporados padrão armazenados nele com o nome Sklearn. conjuntos de dados. Para trabalhar nos conjuntos de dados, podemos lê -los usando repositórios de conjuntos de dados padrão da Sklearn ou gerando -os.
Os conjuntos de dados que a Sklearn fornece ao seu usuário são alguns conjuntos de dados de brinquedos relativamente pequenos e outros conjuntos de dados do mundo real que são enormes e têm informações relacionadas a aplicativos mundanos. O tamanho padrão e os pequenos conjuntos de dados podem ser obtidos usando os carregadores de dados, enquanto os conjuntos de dados do mundo real são carregados por meio de pecadores de conjunto de dados,.
Neste exemplo, primeiro importaremos os conjuntos de dados de brinquedos de “Sklearn. conjuntos de dados ”. Para importar o conjunto de dados, usaremos a Sklearn.conjuntos de dados. Sklearn.Os conjuntos de dados permitem importar os conjuntos de dados de seus conjuntos de dados padrão. Diferentes conjuntos de dados podem ser carregados de Sklearn.conjuntos de dados usando este comando.
$ de Sklearn. conjuntos de dados import load_digits
Aqui importamos o conjunto de dados dos dígitos do Sklearn.conjuntos de dados. Podemos carregar qualquer outro conjunto de dados usando o mesmo comando com a modificação simples; Ou seja, temos que substituir os "load_digits" pelo nome desse conjunto de dados específico que queremos carregar no comando acima mencionado. Agora, na próxima etapa, carregaremos o conjunto de dados usando o método "Data Set_Name ()" e depois o armazenamos em qualquer variável, digamos o conjunto de dados, como fizemos neste comando
$ DATASET = load_digits ().
Até esta etapa, o conjunto de dados foi baixado nos dígitos. Para exibir os dados neste conjunto de dados, usaremos a função de impressão e passaremos o nome da variável.dados nos argumentos da função de impressão.
$ print (conjunto de dados.dados )
Agora, executaremos esses comandos mencionados explicitamente na forma de um código e fornecerá a saída como:
Depois de executar o código, obtivemos uma saída que exibe todos os dados armazenados no conjunto de dados de carregamento _digits.
Se queremos saber sobre a especificação do conjunto de dados em termos de quantas classes existem no conjunto de dados ou quantos recursos existem para o conjunto de dados mais o tamanho da amostra do conjunto de dados, ou seja, quantos exemplos foram dados para cada conjunto de dados.
Para obter essas informações, podemos simplesmente usar a função “DataSet_varaIable Nome. forma". Para implementar isso, importe o conjunto de dados (load_iris) da Sklearn.conjuntos de dados e, em seguida, carregue este conjunto de dados chamando o método de "load_iris ()" e armazenando -o em "Iris. carregar". Em seguida, imprima a especificação do conjunto de dados usando a impressão (loadiris.forma) da seguinte maneira:
O código acima teria a seguinte saída após a execução:
A saída retornou os valores (150, 4). Isso significa que o conjunto de dados possui 150 exemplos de amostra e 4 atributos que podemos usar para criar nosso algoritmo de aprendizado de máquina de acordo com a demanda.
No próximo exemplo, agora aprenderemos a importar conjuntos de dados do mundo real e trabalhará neles. Para dados do mundo real, buscamos os arquivos usando a função de busca que baixa e extrai o conjunto de dados do cache/arquivo do site específico e o carrega no Sklearn. conjuntos de dados.
Vamos pegar dados do mundo real dos conjuntos de dados do mundo real usando o Sklearn.conjuntos de dados e trabalhe nisso. Aqui gostaríamos de pegar os dados de alguns sites de grupo de notícias, “sites de grupos de notícias de TV”. Agora vamos importar o conjunto de dados para este site específico, primeiro buscando os arquivos do repositório do site. Em seguida, carregaremos os dados de treinamento dos arquivos buscados desses dados para o Sklearn.conjuntos de dados chamando o método de carregamento, eu.e., “DataSet_Name (Subset =” Teste ou Dados de Treino a serem inseridos ”)” e depois o armazenará em alguma variável “NewspaperDataload”.
Depois disso, simplesmente exibiremos os nomes de destino do conjunto de dados. “Nomes de destino” são os arquivos que contêm os arquivos de dados reais dos conjuntos de dados. Vamos chamar a função de impressão para exibir os nomes dos arquivos presentes no conjunto de dados escrevendo os comandos:
$ pprint (lista (“DataSeTName. Target ”_Names)))
Nós importamos o Pprint aqui porque o nome de destino contém a lista do arquivo, e queremos que esta lista seja exibida como é. Para exibir esta lista, importamos o pacote Pprint primeiro e, em seguida, usamos a lista dos nomes de arquivos no conjunto de dados que já carregamos em “Sklearn.conjuntos de dados ”buscando os arquivos do site. Implementamos o código acima mencionado no Python, e sua saída saiu assim:
Agora a lista dos conjuntos de dados foi exibida pelo sistema. Se queremos saber os atributos deste conjunto de dados, e.g., O número de exemplos de amostra que o conjunto de dados contém, o número total de recursos no conjunto de dados, etc. Podemos simplesmente usar a impressão (DataSet_Name. nome do arquivo. forma) como, como já explicamos, todas as informações do conjunto de dados são armazenadas no arquivo file_name ou Target_name, e elas retornarão as informações de atributo do conjunto de dados como ele é.
$ Print (Dataload de jornais. nome do arquivo. forma )
Etapa 04: Seleção de recursos
Nos algoritmos de aprendizado de máquina, o aspecto mais importante que controla a saída do algoritmo são os recursos. Os recursos contribuem principalmente para a construção de qualquer algoritmo de aprendizado de máquina. Todo o processamento é feito nos conjuntos de dados que são baseados nos recursos. Os recursos podem tornar os algoritmos robustos ou uma falha completa em termos de precisão (melhor previsão ou estimativa) para o limite da decisão. Se houver recursos redundantes ou um número maior de recursos necessários, isso contribui para o excesso de ajuste na saída.
O excesso de ajuste é o fenômeno em que um modelo que é treinado nos conjuntos de dados com mais recursos do que o necessário e tem um erro de treinamento mais próximo de zero, mas quando é treinado no conjunto de dados de teste, o modelo não funciona bem nesse conjunto de dados de teste e, portanto, falha em tomar as decisões corretas. Para evitar as chances de o modelo treinado ser equipado, lançamos alguns dos recursos desnecessários. Essa redução da dimensionalidade pode ser feita de várias maneiras usando o Scikit Learn.
Exemplo #01
O primeiro método para remover o recurso é através de um limite de baixa variação; Nesse tipo de seleção de recursos, removemos os recursos dos conjuntos de dados com baixa variação que estão abaixo dos limites fornecidos. Recursos de baixa variação são aqueles que contribuem com o mesmo valor em todo o conjunto de dados.
Vamos tentar um exemplo para redução de recursos. Suponha que tenhamos um conjunto de dados que tenha três recursos em dados binários. Em nosso exemplo, os conjuntos de dados Digit têm quatro colunas como seus quatro recursos. Se quisermos remover um recurso com todos os seus exemplos de amostra do conjunto de dados, usaremos a fórmula de variação e construiremos um limite de variação sobre isso. Se algum recurso tiver baixa variação, o limite será removido do conjunto de dados.
Primeiro, imporemos o limiar de variação do “Sklearn Feature_selection”. Uma vez importado o limite de variação, definiremos o valor desse limite que, no nosso caso, definimos como “0.5 ”. Portanto, quaisquer colunas de recurso que tenham um valor menor que esse limite abandonará esse conjunto de dados de dígitos.
Para fazer isso, chamaremos o método de "limite de variância ()". Nos argumentos da função, passaremos o valor limite para ser 0.5 e armazene -o em algum "limiar" variável. Depois disso, chamaremos a função de "limiar. fit_transform () ”e passe o conjunto de dados para esta função e deixe -o armazená -lo com o nome new_dataset. Depois de terminar essas etapas, imprimiremos o conjunto de dados como mostrado:
Como pode ser visto na saída que, antes de aplicarmos o limite de variação ao conjunto de dados, ele tinha 4 recursos e agora após a aplicação do limite de variação no conjunto de dados, instruímos o sistema a remover todas as colunas com variação abaixo do Valor limiar, eu.e., 0.5, a saída exibe três colunas no conjunto de dados, o que significa que uma coluna foi calculada para ter uma variação menor que o limite, por isso foi eliminado do conjunto de dados para evitar a redundância no conjunto de dados e fazer o modelo treinado nos dados definido para ser mais preciso em termos de precisão e evitar o excesso de ajuste.
Exemplo #02
O segundo método para selecionar os recursos no conjunto de dados é fornecido pelo método "Selecionar K-Best". Para a implementação deste método, o conjunto de dados da IRIS será importado dos "Sklearndatasets" e, em seguida, carregaremos esse conjunto de dados e o salvaremos em alguma variável aleatória, como a IRIS. Então, para carregar o conjunto de dados, chamaremos de "LoadDataset_Name ()".
Chi2 mede a diferença entre recursos esperados e observados e é usado para tarefas de classificação. Depois de carregar o conjunto de dados em íris e importar o K Select K Best e Chi2, agora os usaremos no “ajuste. função transform () ”. O selecionkBest (Chi2, k = 2). ajustar.transform (), primeiro se encaixa nos dados que tomam os dados de treinamento como entrada e depois transformando -os. Em seguida, o K no método selectkBest diminui as colunas e seleciona os recursos que obtiveram os recursos mais altos nos recursos. No nosso caso, selecionaremos os dois recursos à medida que selecionamos o valor k igual a 2.
Neste exemplo, quando simplesmente carregamos o conjunto de dados e o exibimos, havia quatro colunas como recursos no conjunto de dados, mas agora depois de aplicarmos o método selectKBest com k = 2 no conjunto de dados agora, o novo conjunto de dados foi lançado tendo Duas colunas como recursos, isso significa que o SelectkBest selecionou os dois melhores recursos do conjunto de dados original.
Exemplo #03
Outra maneira de selecionar o recurso importante do conjunto de dados é dado pelo Scikit Learn usando a “Eliminação Recursiva de Recurso (RFE)”. RFE descarta os recursos menos importantes do conjunto de dados fazendo o treinamento recursivo do conjunto de dados. O RFE seleciona o número do recurso por si mesma usando a mediana do número total de recursos no conjunto de dados e ele solta apenas um recurso do conjunto de dados em cada iteração. Para implementar o RFE, primeiro importe as bibliotecas necessárias para criar o código através desses comandos.
Agora, importamos com sucesso os pacotes para RFE da Sklearn. recurso. seleção. Para criar o conjunto de dados, carregamos a função "make_regression ()" e, em seus argumentos, passamos os parâmetros que queremos no conjunto de dados.
$ X, y = make_regression (n_samples = 10000, n_features = 100, n_informative = 2)
$ print (x.forma)
Em seguida, imprimimos este conjunto de dados para saber sobre a forma ou atributos exatos do conjunto de dados. Depois de exibir o conjunto de dados, agora usaremos o recurso Recursive Eliminator. Para esse fim, faremos um modelo como DecisionTreeRgressor (). Depois que o modelo é concluído agora usando o RFECV () que importamos anteriormente, passaremos o detalhe, modelo/estimador, passo, pontuação e CV como os parâmetros que estão sendo necessários nos argumentos do RFECV.
Agora, para remover o recurso recursivo, encaixaremos e transformaremos os dados. Todo o procedimento explicado pode ser escrito como o código abaixo:
Agora, os recursos serão retirados recursivamente de acordo com nossa exigência após cada iteração, pois pode ser mostrado claramente na saída. Essa eliminação de recursos recursiva será continuada até chegarmos ao ponto em que ficamos com dois recursos importantes do total de 100 recursos presentes no conjunto de dados original.
Exemplo #04
Outro método que podemos usar para remover os recursos extras, ou podemos simplesmente abandoná -los devido à sua redundância, é o "modelo selectFrom" junto com os "modelos lineares". Quando as teses modelos lineares são de alguma forma penalizada com a norma L1, sua solução existe escassamente, pois a maioria de seus coeficientes se torna igual a zero.
Na redução da dimensionalidade ou seleção de recursos, esses modelos lineares, juntamente com o modelo selectFrom, ajudam a selecionar esse coeficiente diferente de zero. Eles trabalham principalmente para o problema de regressão. Para implementar o modelo SelectFrom, precisamos primeiro importar o linearsvc da Sklearn.SVM, LinearSVC é o classificador de vetor de suporte linear que encontra a melhor linha de ajuste (hiperplano) para dividir e classificar os dados em diferentes categorias; Depois de obter o hiperplano no LSVC, podemos fornecer qualquer recurso a este modelo de melhor ajuste para saber qual classe esse recurso pertenceria, então importaremos o conjunto de dados do Sklearn. Conjuntos ATA e, depois disso, teremos que importar o "Modelo SelectFrom" da Sklearn.Seleção de recursos.
Após a importação dos pacotes necessários, carregamos o conjunto de dados da IRIS usando load_dataset () e, em seguida, exibimos os atributos do conjunto de dados da IRIS em termos de exemplos de amostra e o número de recursos que ele tem usando o “ .Método da forma ”. Depois de conhecer a forma do conjunto de dados, agora aplicaremos o “linearsvc ().FIT (_Landed Data Set) ”Modelo com C = 0.01, uma penalidade do linearsvc = L1 como seu argumento de entrada. Em seguida, crie o modelo usando “selectFrom Model ()” e transforme o modelo usando “Modelo.transformar()". Agora exiba o novo conjunto de dados de transformação e mostre seu atributo usando os dados “Set_New.forma".
A forma do conjunto de dados antes de aplicar o "modelo selectFrom" para a seleção de recursos foi (150, 4), o que significa que ele tinha 150 exemplos de amostra e quatro atributos, mas uma vez que aplicamos a seleção de recursos no conjunto de dados usando "linearsvc ”E selecioneFrom Model A forma do conjunto de dados foi transformada em (150, 3), o que significa que o recurso foi eliminado do conjunto de dados.
Etapa 05: Pré -processamento de dados
Os conjuntos de dados com os quais trabalhamos para desenvolver e treinar diferentes algoritmos de aprendizado de máquina neles nem sempre são os da forma perfeita para criar o modelo. Devemos modificar esses conjuntos de dados de acordo com nossos requisitos. A primeira etapa que precisamos fazer depois de carregar o conjunto de dados e antes de treinar o modelo é o pré-processamento de dados. Ao pré-processamento de dados, queremos dizer:
- Escala de recursos
- Normalização / padronização de recursos
Escala de recursos
A tarefa mais importante no pré-processamento de dados é a escala de recursos. A escala de recursos é feita para fazer com que todos os recursos do conjunto de dados tenham a mesma unidade; Caso contrário, o algoritmo não treinará corretamente e pode afetar o desempenho do algoritmo, diminuindo o processo. A escala pode ser feita usando o minmaxscaler ou maxabsscaler. A escala de recursos define os valores dos recursos entre zero e um principalmente, e às vezes sob demanda, ele pode limitar o valor de um recurso ao tamanho da unidade.
Aqui, implementaremos um exemplo no qual primeiro vamos importar pré -processamento do Sklearn, e depois importaremos o Numpy. Numpy é usado nas funções em que precisamos trabalhar com matrizes. Agora vamos criar um nd-Array usando Numpy. Para fazer o recurso de escala nesta matriz que criamos, primeiro, usaremos o método “Pré -processamento. Minmaxscaler () ”. Após esta etapa, aplicamos o minmaxscaler à matriz chamando o método de "minmaxscaler. fit_transform () ”e passará por essa matriz em seus argumentos. O código pode ser reescrito como:
A saída após a escala do recurso foi realizada no "x", fornece o valor de uma matriz entre zero e um. O MaxabsScaler funciona principalmente do mesmo. O código para o MaxabsScaler é dado por:
Na saída, os valores dos dados “x” foram retornados na forma contínua da faixa variando entre -1 a +1.
Normalização / padronização de recursos
Aprenderemos sobre as técnicas de pré-processamento de dados neste exemplo. Vamos primeiro importação do pré -processamento de Sklearn e depois de importar o pré -processamento do Sklearn, depois também importe o Numpy, já que agora vamos trabalhar com as matrizes do ND. Agora crie um nd-Array e armazene-o em "X". Agora precisamos executar a normalização/padronização média nesses dados. Para fazer isso, usaremos o método convencional “pré -processamento. StandardsCaler. ajuste ("digite aqui os dados a serem normalizados") ". O valor da função será salvo em uma variável, e.g., Scaler. Agora execute a padronização nos dados especificados x com o método, e.g. “Scaler. Transform ("Data") "e exiba os dados recém -transformados então:
Os dados "x" foram padronizados com o valor médio mais próximo de zero. A normalização/padronização dos dados é feita para evitar qualquer redundante ou duplicata no conjunto de dados. A normalização/ padronização média garante manter apenas os dados relacionados nos conjuntos de dados. Além disso, também lida com quaisquer problemas causados devido a modificações, e.g., exclusão de dados, adição de novos dados ou qualquer atualização nos conjuntos de dados que possam se tornar um obstáculo no futuro.
Agora que aprendemos mais sobre os pacotes Scikit Learn que podemos usar para construir os algoritmos de aprendizado de máquina. Devemos testar nossas habilidades com o Scikit Aprenda uma função que usamos acima neste guia e desenvolver um algoritmo de aprendizado de máquina para primeiro treinar um modelo no conjunto de dados específico e depois testar esse modelo executando -o no conjunto de dados de teste desconhecido para Ganhe uma experiência prática neste Scikit Learn Functions/Pacotes. Vamos iniciar a implementação do Scikit Learn Functions para o algoritmo ou modelo de aprendizado de máquina.
Etapa 06: Treinamento de modelo usando Scikit Learn
Treinaremos o "Modelo de Regressão Linear" no conjunto de dados de preços da casa que nos criaremos no código posteriormente. A regressão linear encontra a melhor linha adequada para os pontos de dados fornecidos no conjunto de dados. Esta linha é plotada nos pontos de dados no gráfico. Usamos essa linha para prever os valores que nosso modelo de trem preverá quando será testado em alguns dados de teste com a crença de que os pontos de dados de saída gerados após a execução dos dados do teste no modelo seguiriam a linha como dados originais ou treinamento os dados foram seguidos.
Para trabalhar com o modelo de regressão linear, precisamos importar a biblioteca Matplotlib e, do Scikit Learn, importaremos o modelo linear, matrizes e qualquer seleção de modelo para treinar o modelo posteriormente no código. Para criar o conjunto de dados do preço da casa, importaremos o NP do Numpy e criaremos os dois nd-Array com nomes "AUDERSQ_FOTAGE_X" e "HOUSEPRICE_Y", respectivamente.
Depois de criar esses dois nd-peças, planejaremos seus valores no enredo usando a “dispersão.plot () ”ao rotular o eixo x do gráfico como a 'área da casa' e o eixo y como o 'preço da casa'. Depois que os pontos de dados forem plotados, treinaremos o modelo usando o "Modelo LinearRegression ()". Em seguida, expandiremos as dimensões do ND-Array "Areasq_Fotaage_X" e, em seguida, será armazenado na nova variável "x_new". Então usaremos o “Model_house.fit () ”e passará o“ x_new ”e“ houseprice_y ”em seus argumentos de entrada para se ajustar ao modelo para a melhor linha.
Criaremos a hipótese da melhor linha ajustada por "y = theta0* x + teta1" e plotaremos essas saídas esperadas para os dados reais e plotar o gráfico. Este gráfico nos informará a melhor linha de ajuste para os pontos de dados fornecidos, com base nos quais prevearemos a saída dos pontos de dados dos dados de teste previstos como corretos ou não.
Este é o gráfico que obtivemos antes de treinar o modelo. Todos os pontos de dados aqui foram plotados seguindo os valores do eixo x e do eixo y.
Este gráfico é a saída do modelo treinado e mostra a melhor linha de ajuste para prever a saída para os pontos de dados se o modelo treinado for avaliado em alguns dados de teste.
Conclusão
O Scikit Learn é uma biblioteca para Python que usa o pacote Sklearn para trabalhar com suas diferentes funções disponíveis para a criação de qualquer algoritmo de aprendizado de máquina. Neste tutorial, aprendemos o Scikit a aprender com as etapas muito básicas (instalação do Scikit Learn on Python para o treinamento complexo de um modelo usando os pacotes Scikit Learn). No meio do nível básico ao complexo, discutimos a plotagem de gráficos, os conjuntos de dados de carregamento, a seleção de recursos e o pré-processamento de dados. Esperamos que você ache este tutorial útil para desenvolver seus conhecimentos sobre o Sci-kit Learn.