Tutorial de Pytorch

Pytorch é uma biblioteca de aprendizado de máquina de código aberto que é usado para Python. A equipe de pesquisa de inteligência artificial do Facebook criou inicialmente, servindo como base para o software pyro da Uber para programação probabilística. É um kit de ferramentas matemático que possibilita calcular modelos de contraste de contraste de maneira eficaz e automática.

Como é direto e adaptável, a API Pytorch é popular entre acadêmicos e pesquisadores, criando novos modelos e aplicativos de aprendizado profundo. Devido ao uso generalizado, já existem numerosas extensões para aplicativos de nicho, como texto, visão computacional e dados de áudio e modelos pré-treinados potencialmente prontos para uso.

Características

As principais características de Pytorch são:

Fácil de usar

Como Pytorch tem uma API intuitiva e depende do Python, é considerado relativamente fácil de usar. A execução do código é simplificada por esta estrutura.

Uso do Python

Este módulo interage perfeitamente com o Python Data Science Stac e é considerado pitônico. Como resultado, pode utilizar todos os recursos e serviços que o ambiente Python fornece.

Gráficos computacionais

Pytorch oferece um ambiente eficaz para gráficos computacionais dinâmicos. Isso permite a modificação de tempo de execução pelo usuário.

Ferramentas e bibliotecas

Uma comunidade vibrante de pesquisadores e criadores estabeleceu uma rede abrangente de ferramentas e bibliotecas para a disseminação de Pytorch e promover o avanço em áreas como visão computacional e aprendizado de reforço.

Benefícios de Pytorch

• É fácil de entender e simples de codificar, porque é baseado em python
• Ativa a depuração simples usando ferramentas de Python bem-amplo
• Pytorch é simples de escalar e tem excelente suporte nas plataformas de nuvem mais populares
• Concentra sua pequena comunidade em código aberto
• Tem a capacidade de exportar modelos de aprendizado no formato comum de troca de rede neural aberta (ONNX)

Diferença entre tocha e pytorch

Torch (Torch7) é uma biblioteca de aprendizado de máquina de freeware e uma estrutura de computação científica com base na linguagem de programação e normalmente acessada usando a interface Lua. Não está mais sendo desenvolvido ativamente.

Pytorch é a biblioteca baseada em uma tocha, pois é direta e adaptável. Em Pytorch, "Py" indica o python onde a "tocha" reflete sua biblioteca de tocha anterior.

Como instalar Pytorch

Lembre -se de que o Python está instalado, particularmente a versão 3.7 ou superior, antes de configurar Pytorch. Python pode ser instalado usando anaconda. Depois de configurar nosso ambiente Python, seguiremos para a próxima etapa da instalação do Pytorch.

Primeiro, temos que criar um ambiente virtual para o CONDA, no qual queremos instalar todos os nossos pacotes e estabelecer o ambiente.

$ CONDA CREATE -N Pytorch Python = 3.7

O CONDA é um gerente de meio ambiente que ajuda a instalar o pacote de programas de aprendizado de máquina. Se você tiver que trabalhar com outra versão do Python, então não precisa mudar para isso. ARIRA gerenciará automaticamente isso. Você só precisa usar alguns comandos para fazer seu ambiente de acordo com sua escolha.

Onde Create é uma palavra -chave para dizer ao compilador para criar um novo ambiente para Pytorch que usará o “Python 3.Versão de 7 ”. Quando nossos pacotes forem baixados com sucesso, ele solicitará sua permissão para instalá -los ou não.

Como seu ambiente é criado com sucesso, ele exibirá a saída, como mostrado no seguinte snippet:

Vamos começar com a instalação do Pytorch:

Abra o link a seguir e vá para o site da Pytorch. Vá para o início da guia e clique em Iniciar localmente.

https: // pytorch.org/get-started/localmente/

Uma zona como a da figura abaixo será vista. O primeiro seletor será o Pytorch Build e selecione estável (1.12.1) A partir das opções fornecidas. Agora, o segundo campo seletor será sua escolha e você poderá selecionar o sistema operacional conforme seus requisitos. Selecionaremos o sistema operacional Windows nas opções fornecidas porque estamos usando o Windows para executar nossas tarefas. A terceira guia será pacote. Escolheremos o CONA das opções fornecidas. Se usarmos qualquer outro pacote, selecionaremos esse pacote.

Na segunda última opção, selecione o nome do idioma que você está usando e, no nosso caso, que será python para que o selecionemos das opções fornecidas. Por fim, selecionaremos a CPU das opções fornecidas porque estamos usando a CPU como nossa plataforma de computação. Se estamos usando outra plataforma como Cuda, selecione CUDA.

Depois de selecionar todas as opções dos seletores fornecidos acima, um comando será mostrado no campo abaixo. Copie esse comando e execute esse comando em seu prompt de comando conda.

No comando anterior, o CONDA será instruído a instalar o Pytorch e outras bibliotecas, Torchvision e Torchaudio, onde a Torchvision é a biblioteca do Python. Foi projetado para fazer testes e estudar no campo da visão computacional mais simples. Possui arquiteturas de modelos, transformações de imagem comuns e outros conjuntos de dados populares para visão computacional.

Torchaudio também é um pacote de pytorch e foi construído para processamento de áudio e sinal de computadores. Ele também possui conjuntos de dados populares, E/S e transformações de áudio comuns.

Quando todos os nossos pacotes forem baixados, ele solicitará sua permissão se deve prosseguir ou não.

Agora, mudando para o próximo passo, ative nossos pacotes de pytorch. Ao fazer isso, executaremos o seguinte comando no prompt de comando anaconda:

$ CONDA Ativa Pytorch

Agora, ativando nossos pacotes Pytorch usando o comando mencionado anteriormente nesta ativação é a palavra -chave usada para instruir o CONDA para ativar a biblioteca Pytorch que já instalamos.

Podemos verificar iniciando o Python se, se estiver em execução, ele exibirá a seguinte saída:

Depois disso, temos que importar a tocha nela; Se exibir um módulo não encontrado erro, isso significa que sua instalação não estava correta. Nesse caso, a instalação estava correta, por isso não mostrou nenhum erro.

Agora, podemos criar um tensor de tocha para verificar se funciona corretamente para fazê -lo; Digamos:

$ x = tocha.rand (3)
$ print (x)

No comando anterior, criamos uma variável "X" e a atribuímos à tocha de valor.Rand, onde Rand indica um valor aleatório. Em seguida, exibimos a saída da tocha usando a função de impressão e passando por nossa variável "x". A captura de tela a seguir mostra como os valores do tensor são mostrados:

Agora, verificando a versão da tocha, importamos a tocha e, usando a função de impressão, passaremos o valor “Torch__version__” para verificar.

$ importar tocha
$ print (tocha.__versão__)

Aqui está a saída para o seguinte comando, como mostrado na figura anterior. E agora, nosso ambiente Pytorch é instalado com sucesso para nosso uso.

Ciclo de vida do modelo de aprendizado profundo pytorch

Projetos envolvendo aprendizado de máquina não são simples; Eles envolvem um ciclo contínuo de melhorar os dados, modelos e avaliação. Este ciclo é essencial para criar um modelo de aprendizado de máquina, pois enfatiza o uso de simulação e resultados para melhorar seu conjunto de dados.

Por mais de dez anos, o aprendizado profundo tem sido um tópico importante e contribuiu para o maior foco do mercado no ML. O desenvolvimento de muitas ferramentas para ajudar na produção de modelos de ML fez com que a indústria de ML experimente.

5 etapas principais para o modelo de vida do modelo de aprendizado profundo são:

1. Preparando dados
2. Definição modal
3. Treinando o modal
4. Avaliação modal
5. Fazendo previsão

Exemplo 1

Neste exemplo, usaremos a biblioteca da Torchvision com um conjunto de dados “FashionMnist” pré-carregado usando a Biblioteca Torchvision de Pytorch, que possui objetos do mundo real.

Quando se trata de trabalhar com dados, Pytorch usa seus dois elementos principais, que são tocha.útil.dados.Dataloader e Torch.útil.dados.Conjunto de dados, permitindo -nos usar seus dados ou conjuntos de dados pré -carregados. O carregador de dados envolve um iterável em torno do conjunto de dados para facilitar a aquisição das amostras, que o conjunto de dados usa para armazenar as amostras e seus rótulos relacionados.

Totensor é usado para aprimoramento e transformação de figuras, enquanto o pacote NN especifica uma coleção de funções de perda prática que normalmente são empregadas. O conjunto de dados da fashionMnist funciona para imagens com elementos que variam de 0-255. Você também pode escrever transformações personalizadas de acordo com suas necessidades. Vamos verificar o código desse cenário na imagem a seguir:

No código superior, atribuímos um conjunto de dados do FashionMnist ao nosso treinamento_data. Esse conjunto de dados atribuído a Training_Data consiste em muitos dados de visão do mundo real, como Cifar e Coco. Empregaremos o conjunto de dados da fashionMnist neste caso. Todos os conjuntos de dados da Torchvision requerem dois parâmetros. Um é transformado e o outro é target_transform. Esses dois parâmetros modificam os rótulos e amostras.

Os resultados mostrados na figura que o acompanha aparecem após a execução do código. Ele começará a baixar o conjunto de dados da biblioteca.

Agora, o conjunto de dados é baixado após a execução do nosso código. Passaremos no conjunto de dados como um parâmetro para Dataloader. Isso nos ajudará na amostragem, embaralhamento, carregamento de dados de multiprocessos e lote automaticamente. No nosso caso, estamos atribuindo 64 ao nosso Batch_size. Como resultado, estamos definindo 64 tamanhos de lote. Todos os elementos do Dataloader iterable poderão retornar uma saída de um lote de 64 rótulos e recursos.

Nós colocamos o trem como verdadeiro porque ele define o módulo. O download também está definido como o modo True, porque precisamos baixar o conjunto de dados para treinar nosso módulo com a ajuda desse conjunto de dados. Passamos dados para o nosso parâmetro raiz porque passaremos as informações para o nosso módulo na forma de dados que baixaremos do pacote Totensor.

Depois de executar nosso código, podemos ver em nossa saída que ele imprimiu as formas de x e y de acordo com nossos argumentos anteriores. Vai baixar as imagens.

Agora, movendo -se em direção à criação modal, criaremos uma classe chamada Rede Neural que herdará NN. O módulo é um parâmetro. Vamos criar uma função chamada init; Nesta função, definiremos as camadas da rede. Em seguida, criaremos uma função com o nome adiante, pois o nome esclarece seu objetivo. Vamos indicar como os dados serão transferidos pela rede na função avançada.

Linear é uma classe de biblioteca NN que aplica uma transformação linear aos dados que passamos para ela. Estamos passando 28*28 como o número de dimensões para a classe linear. Relu é uma função em pacotes NN, que lida com os elementos negativos, substituindo -os por 0. Para acelerar todo o processo para a rede neural, usamos os recursos de nossa placa de gráfico se eles estiverem disponíveis para utilização. Vamos verificar o código desse cenário na seguinte imagem afixada:

A função init é o método de inicialização em pytorch. É necessário para deixar Pytorch obter os diretórios que contêm bibliotecas. Nisso, passamos por si mesmo. Enquanto na função avançada, passamos os tensores de entrada como parâmetros, e a função avançada retorna tensores de saída calculando seus tensores de entrada. Nisso, passamos dois parâmetros, "self" e "x", para a função avançada. A função avançada também define como o seu módulo funcionará da entrada à saída.

Depois disso, a saída do código anterior aparece na captura de tela a seguir:

Após o processo que realizamos nas etapas anteriores, treinaremos nosso modelo. Devemos empregar um otimizador e uma função de perda para realizar isso. Um procedimento de função de perda determina a discrepância entre a saída atual de um algoritmo e a saída prevista. O otimizador ajuda o sistema a selecionar a melhor escolha de um conjunto de opções possíveis que são fáceis e não explorem restrições. Vamos verificar o código desse cenário na imagem afixada mostrada abaixo:

Epoch é um parâmetro que especifica o número de vezes que um algoritmo de aprendizado será executado pelo conjunto de dados que fornecemos para treinamento. No nosso caso, definimos para 5, o que significa que ele passará por nosso conjunto de dados 5 vezes durante o treinamento.

Depois de inicializar as épocas, usaremos um loop for, que executará o número de vezes "T" que declaramos em épocas. Neste loop, ele executará a função treinada 5 vezes e a executará. Depois que toda a execução "para loop" é concluída, ela imprimirá o texto "feito".

O snippet a seguir exibe a saída da função treinada das épocas:

Exemplo 2

Nesse caso, resolver o problema de ajustar y = sin (x) com um polinômio de terceira ordem será suficiente.

Método 1

O pacote Optim, fornecido por Pytorch, será usado nesta técnica. "Tocha.Optim ”é um pacote Pytorch responsável pela implementação de diferentes técnicas de otimização. A maioria das técnicas frequentemente usadas já é implementada e a interface é suficientemente aberta para que a futura integração futura de outras mais complexas seja possível. Mudando manualmente os tensores que contêm parâmetros aprendidos com tocha.Sem graduação, os pesos de nossos modelos () são atualizados.

Também usaremos o pacote NN para declarar nosso modal, mas usaremos o RMSPOP para otimizar o modelo porque ele fornece o pacote de tocha que é fornecido pelo Optim.

Vamos prosseguir para o nosso código para criar um tensor responsável por manter dados para entrada e saída. No nosso caso, criamos duas variáveis, "A" e "B". Em seguida, definiremos os tensores de entrada chamados "var" e "myvar", que são tensores de entrada x^, x^2 e x^3.

Depois disso, declararemos funções modais e de perda usando o pacote NN. Crie um otimizador usando o pacote Optim para alterar os pesos do modelo em nosso nome. O RMSPROP será usado neste caso; O pacote Optim inclui inúmeras outras técnicas de otimização. A primeira entrada do construtor RMSPROP instrui o otimizador em que tensores deve ser modificado. Crie um otimizador usando o pacote Optim para alterar os pesos do modelo em nosso nome. O RMSPROP será usado neste caso; O pacote Optim inclui inúmeras outras técnicas de otimização. O código para a explicação anterior pode ser encontrado na tela Spyder a seguir:

Então, na etapa seguinte, calcularemos o Y previsto, passando por Myvar:

$ y_pred = modal (myvar)

Nele, y_predicat é a variável à qual atribuímos a função modal à qual o valor "myvar" é passado. A perda será calculada e exibida. Isso é causado pelo fato de que os gradientes são coletados dinamicamente em buffers sempre que.para trás () é invocado.

perda.para trás () determinará o gradiente de perda com consideração ao modal. Quando a função de etapa de um otimizador é invocada, seus parâmetros são atualizados. Os recursos de entrada das camadas lineares são multiplicados pela matriz de peso para gerar os recursos de saída. Os recursos de entrada são passados ​​para uma camada linear como um tensor unidimensional que foi demolido e são multiplicados pela matriz de peso. No final do código, ele exibirá a saída como resultado na forma da equação.

Método 2

No método a seguir, usaremos pacotes de tensor e autograd. Primeiro, importe nossas bibliotecas de tocha e matemática para este programa e depois defina nossas variáveis ​​"dtype". Aqui, atribuímos a tocha de valor.Float como realizado no exemplo anterior e definiu a variável "dispositivo". Nós novamente atribuímos a tocha de valor.dispositivo ("CPU") que é usado para definir a plataforma a ser usada.

Para manter entradas e saídas, crie tensores. Supondo que isso requer grad = false, o passe para trás não precisa calcular gradientes sobre esses tensores por padrão. Faça pesos usando tensores aleatórios. Exigimos quatro pesos para um polinômio da terceira ordem: y = a + b x + c x^2 + d x^3 demandas de configuração. Desejamos calcular gradientes relativos a esses tensores durante o passe para trás, o que é indicado pelo valor _grad = true.

Calcule e exibir perda utilizando funções tensores. A perda se torna um tensor com o formulário (1) perda. O valor escalar da perda é retornado pelo item (). O código para a explicação anterior pode ser encontrado na tela Spyder a seguir:

Nesse caso, o passe para trás da nossa rede neural deve ser gerenciado manualmente. Não é fisicamente difícil para a rede direta de duas camadas. No entanto, pode se tornar rapidamente complicado para grandes redes complexas. Felizmente, podemos utilizar diferenciação automática para mecanizar o processo de um passe para trás em redes neurais. A biblioteca AutoGRAD em Pytorch fornece essa funcionalidade com muita precisão; Ao usar o AutoGRAD, o passe para a frente de uma rede caracterizará um gráfico computacional. O gráfico terá nós e bordas; Os tensores são representados usando nós, e as arestas representam os métodos que retornarão tensores de saída, tomando tensores de entrada como argumentos.

Ler este gráfico ajuda a calcular gradientes facilmente. Parece uma tarefa difícil, mas na realidade, essa prática é muito simples e direta. Se "x" for um tensor e o atributo "requer graduado" está definido como true. Portanto, X é um tensor que aborda um nó em um gráfico computacional. x.Grad é outro tensor que segura uma inclinação de "x" para algum valor escalar. Aqui, demonstramos ajustar uma onda seno. Agora, não há necessidade de executar manualmente a pausa para trás através da rede.

Método 3

Neste exemplo, usaremos o módulo Numpy. Numpy é uma biblioteca Python para a linguagem de programação que suporta matrizes e matrizes substanciais e multidimensionais. Além disso, uma quantidade significativa de operações matemáticas de alto nível para operar nessas matrizes. Numpy é uma plataforma genérica para calcular operações científicas; não envolve gráficos de aprendizado ou computação profundos.

Usando operações numpy, podemos facilmente encaixar um polinômio de terceira ordem em uma função "sin". Para isso, primeiro importaremos as bibliotecas numpy e matemática. A matemática é o pacote usado para importar operações matemáticas. Vamos verificar o código desse cenário na imagem a seguir:

Primeiro inicializamos duas variáveis ​​denominadas "var1" e "var2" e atribuímos suas funções. Aqui, NP.A função Linspace é um método python que nos ajuda a criar sequências numéricas. Isso nos ajuda a gerar vetores com espaço linear. É o mesmo que o sinal do cólon, mas a única diferença entre o sinal do cólon e é que ele nos fornece controle direto sobre o número de pontos. Para esta função, passamos três parâmetros que são “-Math.pi "," Matemática.pi "e" 200 ", no qual 200 é o intervalo em que o cálculo será feito. E a segunda função que passamos para o VAR2 é “NP.sin (var1) ”, que é usado para calcular o seno dos valores que serão armazenados em“ var1 ”.

Em seguida, inicializamos quatro variáveis ​​chamadas "A", "B", "C" e "D" para essas variáveis ​​que passamos por valores aleatórios. Em seguida, inicializamos um loop para o qual passamos a variável "T", indicando o tempo e o intervalo para 200.

Depois disso, defina outra variável, "VAR2_PRED", ao qual atribuiremos a operação matemática para calcular o agregado e depois passaremos para a variável chamada "perda". A perda será responsável por calcular a perda VAR "var2_pred".

Mudando para a próxima etapa, onde usamos a afirmação IF, que será responsável por calcular o cálculo de "t%10 == 9", ele levará o modo de "T" com o valor 10 e incrementá -lo por 9. Imprimirá a perda desses valores obtidos da instrução IF anterior.

Depois de todos esses cálculos em que o loop for termina, ele resumirá todos os valores, e a última operação de impressão será calculada no final do loop for e será exibida como resultado, como mostrado no snippet abaixo:

Método 4

Neste pedaço de código, usaremos o pacote Tensor. Uma matriz Numpy e um tensor de pytorch são teoricamente equivalentes porque um tensor é uma matriz multidimensional, e Pytorch oferece uma variedade de métodos para trabalhar com eles. Os tensores são uma ferramenta de computação científica de uso geral que pode monitorar gradientes e gráficos computacionais em segundo plano. Os tensores de pytorch podem usar GPUs para acelerar suas operações numéricas, ao contrário do Numpy. Um tensor pytorch pode ser executado em uma GPU em alguns passos fáceis.

Nesta parte do código, importamos duas bibliotecas, tocha e matemática. Como usaremos uma tocha neste código e funcionalidades matemáticas, definimos uma variável chamada "dtype". Atribuímos tocadores de dados.Float porque estamos realizando operações matemáticas que retornarão valores em pontos. Para armazenar valores decimais, usamos o Datatype Float.

Em seguida, declaramos outra variável chamada "dispositivo" com a atribuição de valores tocha.Dispositivo (“CPU”) porque selecionamos a CPU como nossa plataforma na instalação de Pytorch. Avançando, inicializamos duas variáveis ​​denominadas var1 "e" var2 "e atribuímos a mesma função que atribuímos no exemplo anterior. Em seguida, criando quatro variáveis ​​que são "A", "B", "C" e "D" estão sendo usadas para criar tensores aleatórios. Cada um tem sua forma única; Também passamos o dispositivo de dados e o DTYPE, que serão inicializados no início de nosso código. Portanto, ele usará os recursos da nossa CPU e assumirá valores na forma de decimais. É indicado que pretendemos calcular gradientes sobre tais tensores durante o passe reverso, afirmando que requer grad = true. Vamos verificar o código desse cenário na seguinte imagem afixada:

Então declaramos um aprendizado_rate = 1e-6. A taxa de aprendizado também é um hiperparâmetro usado para o treinamento de redes neurais. Tem um valor muito pequeno que deve ser maior que 0.0 e menos de 1.0, o que significa que deve ser um valor positivo. O ritmo da aprendizagem aumenta com a crescente taxa de aprendizado.

Depois disso, abriremos um loop que será executado 200 vezes e executaremos operações matemáticas em nossas variáveis. Onde quer que T%100 seja igual a 99, o loop imprimirá o número de vezes que é executado e parado. Depois disso, o resultado será publicado quando nossa iteração termina, conforme exibido na captura de tela a seguir:

Método 5

Neste método, criaremos nossa função AutoGRAD usando subclasses Pytorch. Todo autogrado primário é dois métodos que operam em tensores. A função avançada leva tensores de entrada e calcula os tensores de saída deles. Em Pytorch, podemos, sem dúvida.AutoGRAD.função e executando as abordagens para frente e para trás.

Agora, os tensores de saída estão sendo adquiridos como parâmetros para as funções atrasadas com alguns valores escalares. O Pytorch nos facilita a definir nosso operador de autograd, permitindo -nos criar uma subclasse que analisa o gradiente dos tensores de entrada com alusão aos mesmos valores escalares. Agora, podemos usar nosso operador AutoGrad, inicializando um construtor e chamando -o de método. Em seguida, passaremos o tensor com dados de entrada como um parâmetro para esse construtor.

No exemplo a seguir, especificamos nosso modal como:

$ y = a+b p_3 (c+dx)
y = a+bp3 (c+dx)
em vez de
y = a+bx+cx^2+dx^3
y = a+bx+cx2+dx3

Compomos nosso método AutoGRAD personalizado, processando a frente e para trás do P3 e usando -o para executar nosso modelo. O código para a explicação a seguir pode ser encontrado na tela do Spyder.

Ao subclassem a tocha, podemos implementar nossas funções exclusivas do AutoGrad.AutoGRAD. Assim, funcionando e colocando em prática os passes para frente e para trás que usam tensores. Temos um tensor segurando a entrada durante o passe para a frente e entregamos um tensor que contém a saída de volta. Um objeto de contexto chamado CTX pode ser usado para armazenar dados para uso no cálculo para trás.

Os tensores podem ser criados para armazenar entrada e saída. Supondo que isso requer grad = false, o passe para trás não precisa calcular gradientes sobre esses tensores por padrão.

Faça pesos usando tensores aleatórios. Para garantir a convergência, os pesos para este exemplo devem ser introduzidos razoavelmente próximos do resultado preciso: y = a + b * p3 (c + d * x). É indicado que pretendemos gerar um gradiente em relação a esses mapeamentos durante um passe para trás, com a configuração que requer grad = true.

A imagem a seguir demonstra a saída que o código anterior gerou:

Método 6

Aqui, usaremos o módulo para resolver este problema. Depois de importar nossa tocha e matemática de bibliotecas desejadas, declararemos os tensores para atribuir informações e saídas. Este exemplo pode ser considerado uma rede neural da camada linear, pois a saída resultante é uma função linear de (x, x2, x3). Vamos verificar o código deste cenário é a seguinte imagem afixada:

Vamos preparar o tensor (x, x2, x3). Como P tem forma (3) e x.O Unqueeze (-1) tem estrutura (200, 1), a semântica de streaming será usada para produzir um tensor de forma nessa situação (200, 3). Para construir nosso modelo como uma série de camadas, use o pacote NN. NN é um módulo que aplica outros módulos sequencialmente para obter sua saída, conhecida como módulo seqüencial. O módulo linear mantém tensores internos por seu viés e peso e usa uma função linear para calcular a saída da entrada. Para calcular o passe para trás, use AutoGRAD.

a.grad, b.O graduado seguirá esta chamada. Tensores que mantêm o gradiente de uma perda relativa às letras A, B, C e D são designadas como C.graduado e d.graduado, respectivamente. Utilizamos o erro médio ao quadrado (MSE) como nossa função de perda, que é definida no pacote NN, juntamente com outras funções de perda proeminente.

PASSE ADIME. O operador __call__ é estendido por objetos de módulo, permitindo que você os chama exatamente como funções. Ao fazer isso, você fornece ao módulo um tensor de dados de entrada e retorna um tensor da saída esperada. Duplicado e perda de impressão A função de perda fornece um tensor que contém a perda depois de receber tensores de nós contendo os valores verdadeiros e antecipados de y.

Calcule o gradiente de uma perda relativa a cada parâmetro de modelo aprendido durante o passe para trás. Devido ao armazenamento interno das características de cada módulo em tensores que exigem um conjunto de graduação para TRUE, essa função calculará gradientes para todos os parâmetros de modelo aprendidos. Você pode acessar a camada inicial do modelo selecionando o primeiro item de uma lista.

Por fim, o resultado é exibido usando a função de impressão quando toda a iteração é executada com sucesso.

Método 7

Tocha.O módulo NN é geralmente o principal bloco de construção de Pytorch. Primeiro, defina um nn.Objeto do módulo e depois chama sua função para a frente para executá -lo. Este método de operação é orientado a objetos. Uma rede Relu totalmente conectada inclui uma camada oculta treinada para prever y de x, reduzindo a distância euclidiana quadrada.

Nesse caso, o modelo é definido como uma subclasse específica do módulo. Você deve definir seu modelo dessa maneira sempre que quiser que ele seja mais complexo do que uma lista direta de todos os módulos atualmente existentes. O código para a explicação anterior pode ser encontrado na tela Spyder a seguir:

Em seguida, calcule o passe para trás usando o AutoGRAD. O método determinaria o gradiente de perda para todos os tensores com graduado necessário = true. A.grad, b.O graduado seguirá esta chamada. Tensores que mantêm o gradiente da perda referente às letras A, B, C e D são designadas como C.graduado e d.graduado, respectivamente. Também podemos definir uma função personalizada em Pytorch.

Depois de criar a classe Polinomial3, declararemos os tensores para manter a entrada e saída. Quatro argumentos são criados e designados como parâmetros de membro na função. Quando usado com módulos, a subclasse de tensores conhecida como parâmetro tem uma propriedade altamente única. Quando atribuído como atributos do módulo, o parâmetro é incluído automaticamente na lista dos parâmetros do módulo e aparecerá na lista de parâmetros do módulo, e.g., em parâmetros () iterador. O método parâmetros () em cada nn.Módulo recupera as variáveis ​​treináveis ​​do módulo. Essas variáveis ​​devem ser explicitamente definidas.

A função encaminhada requer um tensor de dados de entrada e um tensor de dados de saída. Podemos aplicar operadores arbitrários aos tensores e módulos definidos no construtor. Construa um otimizador e nossa função de perda. Os parâmetros treináveis, que são membros do modelo e são especificados com a tocha.nn.O parâmetro no construtor SGD seria incluído na chamada para modelar.parâmetros (). Então, no passe para a frente, calcule o y previsto y (y_pred) e passe a variável "var".No final, os gradientes zero executarão automaticamente o passe para trás e executarão os pesos.

A descida de gradiente estocástica (SGD) é um otimizador que pertence à família de descida de gradiente e é uma técnica de otimização bem conhecida usada em aprendizado profundo e aprendizado de máquina. O termo "estocástico" refere -se a um sistema acoplado ou vinculado à probabilidade aleatória no otimizador SGD.

Por fim, calcularemos a perda e a imprimiremos atribuindo a função de critério responsável pelo cálculo da perda. Passamos o Y previsto e o modal que treinamos. Depois declarar se a declaração que está calculando o modo por 10 dos valores variáveis ​​“T”. Em seguida, ele o aumentará em 9, e o valor resultante de t é passado para a função de impressão para a qual a perda será calculada.

No final do código, o resultado será executado com sucesso, conforme mostrado na figura a seguir:

Conclusão

A aplicação da API Pytorch para atividades típicas de criação de modelos de aprendizado profundo é o objetivo central do tutorial. As informações que você estudou neste artigo devem facilitar a colocação de quaisquer conceitos sofisticados de Pytorch que você possa ter pensado e aprender módulos Pytorch a partir da instalação básica do Pytorch no Python para o treinamento complexo de um modelo. Também discutimos as diferentes maneiras de implementar um único exemplo usando diferentes módulos, Numpy, Tensor Tensor, Torch e AutoGRAD, estabelecendo uma nova função AutoGRAD, função ideal, módulos NN e também o módulo NN personalizado. A plataforma usada para executar nosso código é Spyder; Você pode usar outras plataformas, como conda, Júpiter e Linux.