Regressão logística usando pytorch

A regressão logística é um algoritmo de aprendizado de máquina conhecido que é usado para resolver problemas de classificação binária. É derivado do algoritmo de regressão linear, que possui uma variável de saída contínua, e a regressão logística pode até classificar mais de duas classes modificando -a ligeiramente. Veremos o conceito de regressão logística e como ela é implementada em Pytorch, uma biblioteca útil para criar aprendizado de máquina e modelos de aprendizado profundo.

Conceito de regressão logística

A regressão logística é um algoritmo de classificação binária. É um algoritmo de tomada de decisão, o que significa que cria limites entre duas classes. Estende o problema de regressão linear que usa um função de ativação em suas saídas para limitá -lo entre 1 e 0. Como resultado, isso é usado para problemas de classificação binária. O gráfico da regressão logística parece a figura abaixo:

Podemos ver que o gráfico está restrito entre 0 e 1. A regressão linear normal pode fornecer o valor alvo como qualquer número real, mas esse não é o caso da regressão logística devido à função sigmóide. A regressão logística é baseada no conceito de estimativa de máxima verossimilhança (MLE). A máxima verossimilhança é simplesmente tirar uma distribuição de probabilidade com um determinado conjunto de parâmetros e perguntar: “Qual é a probabilidade de eu ver esses dados se meus dados fossem gerados a partir dessa distribuição de probabilidade?”Funciona calculando a probabilidade de cada ponto de dados individual e, em seguida, multiplicando todas essas probabilidades. Na prática, adicionamos os logaritmos das probabilidades.

Se precisarmos construir um modelo de aprendizado de máquina, cada ponto de dados da variável independente será x1 * w1 + x2 * w2… e assim por diante, produzindo um valor entre 0 e 1 quando passados ​​pela função de ativação. Se tomarmos 0.50 como fator ou limiar decisivo. Então, qualquer resultado maior que 0.5 é considerado um 1, enquanto qualquer resultado menor que esse é considerado um 0.

Para mais de duas classes, usamos a abordagem de um-VS-All. One-vs-tudo, também conhecido como One-VS-REST, é um processo de classificação ML Multilabel e multiclasse. Funciona primeiro treinando um classificador binário para cada categoria e depois ajustando cada classificador a cada entrada para determinar qual classe a entrada pertence a. Se o seu problema tiver n classes, o One-VS-tudo converterá seu conjunto de dados de treinamento em problemas de classificação binária.

A função de perda associada à regressão logística é Entropia cruzada binária qual é o inverso do ganho de informação. Isso também é conhecido como o nome perda de log. A função de perda é dada pela equação:

O que é a função de perda?

Uma função de perda é uma métrica matemática que queremos reduzir. Queremos construir um modelo que possa prever com precisão o que queremos, e uma maneira de medir o desempenho do modelo é analisar a perda, pois sabemos o que o modelo sai e o que devemos estar recebendo. Podemos treinar e melhorar nosso modelo usando essa perda e ajustando os parâmetros do modelo de acordo. As funções de perda variam dependendo do tipo de algoritmo. Para regressão linear, erro ao quadrado médio e erro médio absoluto são funções de perda populares, enquanto a entropia cruzada é apropriada para problemas de classificação.

Qual é a função de ativação?

As funções de ativação são simplesmente funções matemáticas que modificam a variável de entrada para fornecer uma nova saída. Isso geralmente é feito no aprendizado de máquina para padronizar os dados ou restringir a entrada a um certo limite. As funções de ação populares são sigmóides, unidade linear retificada (relu), tan (h), etc.

O que é Pytorch?

Pytorch é uma alternativa popular de aprendizado profundo que funciona com a tocha. Foi criado pelo departamento de IA do Facebook, mas pode ser usado de maneira semelhante a outras opções. É usado para desenvolver uma variedade de modelos, mas é mais amplamente aplicado nos casos de uso de processamento de linguagem natural (PNL). O Pytorch é sempre uma ótima opção se você deseja construir modelos com muito poucos recursos e deseja uma biblioteca fácil de usar, fácil de usar e leve para seus modelos. Também parece natural, o que ajuda na conclusão do processo. Usaremos o Pytorch para a implementação de nossos modelos devido aos motivos mencionados. No entanto, o algoritmo permanece o mesmo com outras alternativas como o Tensorflow.

Implementando regressão logística em pytorch

Usaremos as etapas abaixo para implementar nosso modelo:

1. Crie uma rede neural com alguns parâmetros que serão atualizados após cada iteração.
2. Itera através dos dados de entrada fornecidos.
3. A entrada passará pela rede usando a propagação avançada.
4. Agora calculamos a perda usando a entropia cruzada binária.
5. Para minimizar a função de custo, atualizamos os parâmetros usando a descida de gradiente.
6. Novamente, faça as mesmas etapas usando parâmetros atualizados.

Estaremos classificando o Conjunto de dados mnist dígitos. Este é um problema popular de aprendizado profundo ensinado a iniciantes.

Vamos primeiro importar as bibliotecas e módulos necessários.

importação de tocha
da tocha.Variável de importação do AutoGRAD
Importar Torchvision.Transforma como transforma
Importar Torchvision.conjuntos de dados como dSets

O próximo passo é importar o conjunto de dados.

trem = dSets.Mnist (root = './dados ', trem = true, transform = transforms.Totensor (), download = false)
teste = dSets.Mnist (root = './dados ', trem = false, transform = transforms.Totensor ())

Use o carregador de dados para tornar seus dados iteráveis

TRAIN_LOADER = TOCH.útil.dados.Dataloader (DataSet = Train, Batch_size = Batch_size, Shuffle = true)
test_loader = tocha.útil.dados.Dataloader (DataSet = Test, Batch_size = Batch_size, Shuffle = false)

Defina o modelo.

Modelo de classe (tocha.nn.Módulo):
def __init __ (self, inp, fora):
super (modelo, eu).__iniciar__()
auto.linear = tocha.nn.Linear (INP, Out)
def forward (self, x):
saídas = self.linear (x)
Retorno saídas

Especifique os hiperparâmetros, otimizador e perda.

lote = 50
n_iters = 1500
épocas = n_iters / (len (trens_dataset) / lote)
INP = 784
out = 10
alfa = 0.001
Model = LogisticRegression (INP, Out)
Perda = tocha.nn.Crossentropyloss ()
otimizador = tocha.Optim.SGD (modelo.parâmetros (), lr = alfa)

Treine o modelo finalmente.

itr = 0
Para Epoch in Range (int (Epochs)):
para i, (imagens, rótulos) em enumerado (trens_loader):
imagens = variável (imagens.View (-1, 28 * 28))
Rótulos = variável (etiquetas)
otimizador.zero_grad ()
saídas = modelo (imagens)
LESTFUNC = perda (saídas, etiquetas)
Perdfunc.para trás()
otimizador.etapa()
ITR+= 1
Se Itr%500 == 0:
correto = 0
total = 0
Para imagens, rótulos em test_loader:
imagens = variável (imagens.View (-1, 28*28))
saídas = modelo (imagens)
_, previsto = tocha.Max (saídas.dados, 1)
total+= rótulos.tamanho (0)
correto+= (previsto == etiquetas).soma()
precisão = 100 * correto/total
print ("iteração é . A perda é . A precisão é .".Formato (ITR, Lossfunc.item (), precisão))

Conclusão

Passamos pela explicação da regressão logística e sua implementação usando Pytorch, que é uma biblioteca popular para o desenvolvimento de modelos de aprendizado profundo. Implementamos o problema de classificação do conjunto de dados do MNIST, onde reconhecemos os dígitos com base nos parâmetros de imagens.