Machine Learning Zero to Hero (Google I/O’19)

[MÚSICA TOCANDO] LAURENCE MORONEY: Então,
a primeira pergunta que surge
, é claro, é que sempre que você vê aprendizado de máquina ou
ouve sobre aprendizado de máquina , parece ser uma
varinha mágica. Seu chefe diz, coloque
aprendizado de máquina em seu aplicativo. Ou, se você ouvir
falar de startups, eles colocaram o aprendizado de máquina
em algum lugar. E então, de repente, eles
se tornam uma empresa viável. Mas o que é aprendizado de máquina? O que é realmente tudo isso? E especialmente para
codificadores, o que é aprendizado de máquina? Na verdade, levantem as mãos rapidamente
se algum de vocês for programador. Sim, é E/S. Acho que
praticamente todos nós, certo, somos programadores. Eu faço palestras assim
o tempo todo. E, às vezes, pergunto
quantas pessoas são programadores e aparecem três ou quatro mãos. Então é divertido podermos explorar
e mostrar muito código hoje.

Então, eu queria falar sobre o
que é aprendizado de máquina do ponto de vista da codificação,
escolhendo um cenário. Você pode imaginar se
estivesse escrevendo um jogo para jogar pedra,
papel e tesoura? E você queria
escrever algo para poder mover sua
mão como uma pedra, um papel ou uma tesoura. O computador
reconheceria isso e seria capaz de jogar com você. Pense em
como seria realmente escrever código. Você teria que extrair
imagens da câmera e começar a olhar
para o conteúdo dessas imagens. E como você
diria a diferença entre uma pedra e uma tesoura? Ou como você
diria a diferença entre uma tesoura e um papel? Isso acabaria
sendo muito código que você teria
que escrever e muito código realmente complicado. E não apenas a
diferença de formas – pense na
diferença de tons de pele, mãos masculinas e mãos femininas,
mãos grandes e mãos pequenas, pessoas com
juntas nodosas como eu, e pessoas com
mãos macias como Karmel. Então, como é que
você acabaria sendo capaz de escrever todo
o código para fazer isso? Seria muito, muito
complicado e, em última análise, não muito viável de escrever.

E é aqui
que começamos a trazer o aprendizado de máquina para ele. Este é um cenário muito simples
, mas você pode pensar que existem
muitos cenários em que é realmente difícil escrever
código para fazer algo, e o aprendizado de máquina
pode ajudar nisso. E sempre gosto de pensar
no aprendizado de máquina dessa maneira. Pense na
programação tradicional. E na programação tradicional,
algo que tem sido nosso pão com manteiga
por muitos anos– todos nós aqui somos programadores– é que pensamos
em expressar algo e expressar regras em
uma linguagem de programação, como Java ou Kotlin,
ou Swift, ou C++.

E essas regras
geralmente agem sobre os dados. E então, a partir
disso, obtemos respostas. Como em pedra, papel e tesoura,
os dados seriam uma imagem. E minhas regras
seriam todos os meus se-então olhando para os pixels naquela
imagem para tentar determinar se algo é uma pedra,
um papel ou uma tesoura. O aprendizado de máquina, então,
muda isso. Ele inverte os eixos sobre isso. E dizemos, ei, em vez
de fazer desta forma , como se tivéssemos que
pensar sobre todas essas regras, e temos que escrever e expressar
todas essas regras em código , e se pudéssemos
fornecer muitas respostas e poderíamos rotular essas respostas
e então fazer uma máquina inferir as regras que mapeiam
uma para a outra? Então, por exemplo, em algo
como pedra, papel e tesoura,
poderíamos dizer que esses são os pixels de uma pedra. E é assim que
uma rocha se parece. E poderíamos obter centenas
ou milhares de imagens de pessoas fazendo uma pedra– então obtemos diversas mãos,
diversos tons de pele, esse tipo de coisa. E dizemos, ei, é assim
que uma rocha se parece.

É assim que um papel se parece. E é assim que uma
tesoura se parece. E se um computador
pode descobrir os padrões entre
eles e pode ser ensinado e pode aprender quais são os
padrões entre eles, agora temos o aprendizado de máquina. Agora, temos um
aplicativo e um computador que
determinou essas coisas para nós. Então, se dermos uma olhada
neste diagrama novamente, e se olharmos para isso
novamente e substituirmos o que estamos falando
criando regras, e dissermos, OK, isso é aprendizado de máquina,
devemos alimentar respostas, vamos alimentar os
dados, e a máquina vai inferir as regras– como isso vai
parecer em tempo de execução? Como posso
executar um aplicativo parecido com este? Então é isso que
vamos chamar de fase de treinamento.

Nós treinamos o que
vai ser chamado de modelo nisso. E esse modelo é
basicamente uma rede neural. E vou
falar muito sobre redes neurais nos próximos minutos. Mas o que é essa rede
neural– vamos envolvê-la. Vamos
chamar isso de modelo. E então, em tempo de execução,
vamos passar os dados, e isso nos dará
algo chamado previsões. Então, por exemplo, se eu o
treinei em muitas pedras, muitos papéis e
muitas tesouras, e vou
levantar meu punho para uma webcam, ele obterá
os dados do meu punho. E vai
devolver o que gostamos de chamar de
previsão que será algo como, ei,
há 80% de chance de ser uma pedra. Há 10% de chance de ser
um papel e 10% de chance de ser uma tesoura. Algo parecido. Portanto, grande parte da terminologia
do aprendizado de máquina é um pouco diferente
da programação tradicional. Estamos chamando isso de
treinamento, em vez de codificação e compilação.

Estamos chamando isso de inferência
e estamos obtendo previsões a partir da inferência. Então, quando você nos ouve
usando termos como esse, é daí que vem tudo. É bem parecido com o
que você já faz com a codificação tradicional. É apenas uma
terminologia ligeiramente diferente. Então, vou
iniciar uma demonstração agora em que vou treinar um modelo
para pedra, papel e tesoura. A demonstração leva alguns
minutos para treinar, então
vou começar antes de voltar às coisas. Então eu vou começar aqui. E está começando. E quando começa a correr, eu
só quero mostrar algo à medida que avança. Então, se você pode
imaginar um computador, vou dar a ele um
monte de dados de pedra, papel e tesoura, e
vou pedir para ver se ele consegue
descobrir as regras para pedra, papel, e tesoura. Portanto, qualquer
item individual de dados que eu der a ele, há
uma chance em três de
acertar na primeira vez. Se fosse puramente aleatório,
e eu dissesse, o que é isso, há uma chance em três de
acertar como uma pedra.

Assim que começo a
treinar, uma das coisas que
quero que vejam aqui é a precisão que, na
primeira vez, a precisão foi na verdade– foi exatamente 0,333. Às vezes, quando executo esta
demonstração, é um pouco mais. Mas a ideia é que, uma vez
que começou a treinar , está ficando tão aleatório. É como, OK, estou apenas
jogando coisas aleatoriamente. Estou fazendo palpites sobre isso. E foi, tipo,
um em três certo. À medida que continuamos,
veremos que está ficando cada vez mais preciso. Na segunda vez
, agora é 53% preciso. E à medida que continua,
ficará cada vez mais preciso. Mas vou voltar aos slides
e explicar o que está
fazendo antes de voltarmos para ver o acabamento. Podemos voltar
aos slides, por favor? OK. Portanto, o código para poder
escrever algo assim se parece com isso. Este é um
código muito simples para criar uma rede neural.

E quero que você se
concentre, antes de tudo , nessas coisas que
descrevi na caixa vermelha. Portanto, essas são as entradas da
rede neural e as saídas provenientes da rede neural. É por isso que adoro falar
sobre redes neurais em E/S, porque
E/S, Entrada/Saída. E você verá que falarei
muito sobre entradas e saídas nisso. Portanto, a entrada para isso é
o tamanho das imagens. Todas as imagens
que vou alimentar a rede neural de
pedras, papéis e tesouras têm 150 quadrados e
uma profundidade de cor de 3 bytes. E é por isso que você
vê 150 por 150 por 3. E então a
saída disso será três coisas,
porque estamos classificando para três
coisas diferentes– uma pedra, um papel ou uma tesoura. Portanto, sempre que você está
olhando para uma rede neural, essas são realmente as
primeiras coisas a serem observadas.

Quais são minhas entradas? Quais são minhas saídas? Como eles se parecem? Mas então há
essa coisa misteriosa no meio
onde criamos este tf.keras.layers.Dense,
e há um 512 lá. E muitas pessoas se
perguntam, bem, o que são essas 512 coisas? Bem, deixe-me tentar
explicar isso visualmente. Visualmente, o que está acontecendo
é o que essas 512 coisas estão no centro deste diagrama — considere-as
como 512 funções. E todas essas funções
têm variáveis ​​internas. E essas variáveis ​​internas
serão apenas inicializadas
com alguns estados aleatórios. Mas o que queremos
fazer é quando começarmos a passar os pixels
das imagens para elas, queremos que eles
tentem descobrir que tipo de saída, com
base nessas entradas, me dará a
saída desejada na parte inferior? Então a função 0
vai pegar todos esses pixels.

A função 1 vai
pegar todos esses pixels. A função 2 vai
pegar todos esses pixels. E se esses pixels têm
a forma de uma rocha , queremos que a saída
da função 0, 1 e 2
até 511 seja enviada para a caixa à esquerda na
parte inferior – para inserir um 1 nessa caixa. E da mesma forma para o papel. Se dissermos, OK, quando os
pixels se parecerem com isso, queremos que suas saídas de F0,
F1 e F2 vão para esta caixa.

E esse é o
processo de aprendizagem. Então, tudo o que está acontecendo –
todo esse aprendizado é quando falamos sobre
aprendizado de máquina, é definir essas
variáveis ​​internas nessas funções para obtermos a saída desejada. Agora, essas
variáveis ​​internas, só para confundir
um pouco mais as coisas, na linguagem do aprendizado de máquina,
tendem a ser chamadas de parâmetros. E então, para mim, como programador
, foi difícil entender isso no começo. Porque para mim,
parâmetros são algo que eu passo para uma função.

Mas, neste caso, quando você ouve
uma pessoa de aprendizado de máquina falar sobre parâmetros,
esses são os valores dentro dessas funções
que serão definidos e
alterados enquanto ele tenta aprender como vou corresponder
essas entradas a essas saídas. Então, se eu voltar
ao código e tentar mostrar isso novamente em ação– agora, lembre-se, minha forma de entrada da
qual falei anteriormente , 150 por 150 por 3,
esses são os pixels que mostrei na visualização. Estou simulando
aqui com caixas cinzas, mas esses são os
pixels que mostrei nos diagramas anteriores.

Minhas funções, agora, são aquela
camada densa no meio, aquelas 512. Então são 512 funções
inicializadas aleatoriamente ou semi-aleatoriamente
inicializadas que vou tentar treinar para
combinar minhas entradas com minhas saídas. E então, é claro,
o fundo– esses três são os três neurônios
que serão minhas saídas. E acabei de dizer a palavra
neurônio pela primeira vez. Mas, em última análise, quando
falamos de neurônios e redes neurais
, não tem nada a ver com o cérebro humano. É uma simulação muito grosseira
de como o cérebro humano faz as coisas. E essas funções internas
que tentam descobrir como combinar as
entradas com as saídas, chamamos de neurônios.

E na minha saída, aqueles
três na parte inferior
também serão neurônios. E é isso que dá o nome de
"redes neurais" a isso. Tende a soar um
pouco misterioso e especial quando o chamamos assim. Mas, no final das contas,
pense nelas como funções com
variáveis ​​inicializadas aleatoriamente que, com o tempo,
tentarão alterar o valor
dessas variáveis para que as entradas correspondam às
saídas desejadas. Então tem essa linha,
a linha model.compile. E o que isso vai fazer? Esse é um termo chique. Não é realmente uma
compilação onde estamos transformando código
em bytecode como antes. Mas pense nos
dois parâmetros para isso. E essas são as
partes mais importantes a serem aprendidas no
aprendizado de máquina – e essas são a perda e o otimizador. Então a ideia é que o
trabalho desses dois é– lembre-se,
anteriormente, eu disse que vai
inicializar aleatoriamente todas essas funções.

E se eles são
inicializados aleatoriamente e eu passo algo
que se parece com uma pedra, há uma
chance em três de acertar como uma
pedra, papel ou tesoura. Então, o que a
função Loss faz é medir os resultados de
todas as milhares de vezes que eu faço isso. Ele descobre o quão bem
ou o quão mal ele fez. E então, com base nisso,
ele passa esses dados para a outra função, que é
chamada de função Otimizador. E a função Optimizer
então gera o próximo palpite onde o palpite é definido como
os parâmetros dessas 512 pequenas funções,
esses 512 neurônios. E se continuarmos repetindo
isso, vamos passar nossos dados. Vamos dar uma olhada. Faremos um palpite.

Veremos se nos
saímos bem ou mal. Então, com base nisso,
otimizaremos e faremos outro palpite. E vamos repetir,
repetir, repetir, até que nossos palpites fiquem cada
vez melhores. E é isso que acontece
no model.fit. Aqui, você pode ver que tenho
model.fit onde epochs– "ee-pocks", "epics", dependendo
de como você pronuncia– é 100. Tudo o que está fazendo é repetir
esse ciclo 100 vezes. Para cada imagem, dê uma
olhada nos parâmetros. se encaixar nesses parâmetros. Adivinhe. Meça o quão bom
ou ruim você foi e, em seguida, repita e continue. E o
otimizador irá torná-lo cada vez melhor e melhor. Então você pode imaginar que da
primeira vez, você vai acertar
aproximadamente uma em cada três vezes. Nas próximas vezes
, vai ficar mais perto, e mais perto, e
mais perto, e melhor, e melhor. Agora, aqueles de nós que sabem
um pouco sobre imagens e processamento de imagens dizem
, OK, isso é bom, mas é um pouco ingênuo.

Estou apenas jogando todos
os pixels da imagem – e talvez muitos desses
pixels nem estejam definidos – em uma
rede neural e fazendo com que ela tente descobrir a partir
desses valores de pixel. Posso fazer isso um
pouco mais inteligente do que isso? E a resposta para isso é sim. E uma das maneiras
de fazer isso um pouco mais inteligente do que
isso é usando algo chamado convoluções. Agora, convoluções é
um termo complicado, com licença do trocadilho. Mas a ideia por trás das
convoluções é que, se você já fez algum
tipo de processamento de imagem, a maneira como você pode aguçar
imagens ou suavizar imagens com coisas como o Photoshop
, é exatamente a mesma coisa. Então, com uma convolução, a
ideia é você dar uma olhada em cada pixel da imagem. Por exemplo, esta
foto de uma mão, e estou apenas olhando para um dos
pixels da unha.

E então esse pixel é o valor 192
na caixa à esquerda aqui. Então, se você der uma olhada em
cada pixel da imagem e olhar para seus
vizinhos imediatos , obterá algo
chamado filtro, que é a caixa cinza à direita. E você multiplica
o valor do pixel pelo valor correspondente
no filtro. E você faz isso para todos
os vizinhos do pixel para obter um novo valor
para o pixel. Isso é o que é uma convolução. Agora, muitos de nós, se
você nunca fez isso antes, pode estar
sentado pensando: por que diabos eu faria isso? Bem, a razão para isso é
que, ao encontrar convoluções e filtros
, torna-se muito, muito bom extrair
recursos em uma imagem. Então deixe-me dar um exemplo. Então, se você olhar para a
imagem à esquerda aqui e eu aplicar um filtro
como este , obterei a
imagem à direita. Agora, o que aconteceu
aqui é que a imagem à esquerda, joguei fora
muito do ruído na imagem. E consegui
detectar linhas verticais. Simplesmente aplicando
um filtro como este, as linhas verticais sobrevivem
através da multiplicação do filtro.

Da mesma forma, se eu
aplicar um filtro como este, as linhas horizontais sobrevivem. E há
muitos filtros por aí que podem ser
inicializados aleatoriamente e que podem ser aprendidos para fazer
coisas como escolher itens em uma imagem, como
olhos, orelhas, dedos ou unhas e
coisas assim. Essa é a ideia
por trás das convoluções. Agora, a próxima coisa
é, OK, se eu vou fazer
muito processamento na minha imagem assim, e
vou fazer treinamento, e vou ter que
ter centenas de filtros para tentar e escolher diferentes
recursos na minha imagem, isso vai ser um monte de dados com os
quais tenho que lidar. E não seria bom se
eu pudesse compactar minhas imagens? Portanto, a compactação é
obtida por meio de algo chamado pooling. E é uma coisa muito,
muito simples. Às vezes, parece
um termo muito complexo para descrever algo simples. Mas quando falamos
de pooling, vou aplicar, por exemplo,
um pool 2 x 2 a uma imagem.

E o que
isso vai fazer é pegar os pixels 2 x 2– como se você olhar
para a minha esquerda aqui, se eu tiver 16
pixels simulados– vou pegar os quatro primeiros
no canto superior esquerdo -canto. E desses quatro,
vou pegar o de maior valor. E então os próximos quatro no
canto superior direito, desses quatro, vou
escolher o maior valor, e assim por diante, e assim por diante. Então, o que isso vai fazer
é efetivamente jogar fora 75% dos meus pixels e apenas manter
o máximo em cada uma dessas 2 x 2 pequenas unidades.

Mas o impacto disso
é realmente interessante quando começamos a combiná-
lo com convoluções. Então, se você olhar para a imagem
que criei anteriormente, onde apliquei o filtro
à imagem de uma pessoa subindo as escadas e, em
seguida, reuni-la , obtenho a imagem
à direita, que tem 1/4 do tamanho da imagem original. Mas não apenas não está
perdendo nenhuma informação vital, como também está aprimorando algumas
das informações vitais que saíram dele. Portanto, o agrupamento é seu amigo quando
você começa a usar convoluções porque, se você tiver 128
filtros, por exemplo , aplicados à
sua imagem , terá 128
cópias de sua imagem. Você terá
128 vezes mais dados. E quando você está lidando
com milhares de imagens, isso vai diminuir seu
tempo de treinamento muito rápido. Mas agrupar, então,
realmente acelera ao diminuir o
tamanho da sua imagem. Agora, quando queremos começar a
aprender com uma rede neural, agora é o caso de, ei,
tenho minha imagem no topo, posso começar a aplicar
convoluções a ela.

Por exemplo, minha imagem
pode ser um rosto sorridente. E uma convolução irá
mantê-lo como um rosto sorridente. Outro pode manter o
contorno circular de uma cabeça. Outro
pode mudar o formato da cabeça, coisas assim. E quando começo a aplicar mais
e mais convoluções a elas e a obter imagens cada vez menores
, em vez de ter uma imagem grande e gorda
que estou tentando classificar, com a qual estou tentando escolher
os recursos para aprender , posso ter muitas pequenas imagens
destacando recursos nisso. Assim, por exemplo, em
pedra, papel, tesoura, minhas circunvoluções podem mostrar,
em alguns casos, cinco dedos ou quatro dedos e um polegar.

E eu sei que isso
vai ser um papel. Ou pode não mostrar nenhum, e eu
sei que vai ser uma pedra. E então começa a tornar o
processo de aprendizado de máquina muito, muito mais simples. Então, para mostrar isso rapidamente , coloquei códigos QR
nesses slides, a propósito. Então, abri o
código de todo o código que estou mostrando aqui e estamos conversando. E este é um
código QR para uma pasta de trabalho onde você pode treinar
um modelo de pedra, papel e tesoura para si mesmo.

Mas uma vez que fazemos as convoluções–
e no início do slide, você viu que eu tinha múltiplas
convoluções descendo. E é assim que o código
para isso ficaria. Eu só tenho uma
camada de convolução, seguida por um pooling. Outra convolução,
seguida por um agrupamento. Outra convolução,
seguida por um agrupamento, etc., etc. Então, o impacto disso–
e lembre-se, primeiro de tudo, no topo, eu tenho
minha forma de entrada, e tenho minha
saída na parte inferior, onde o Dense é igual a 3. Então, vou
voltar para a demonstração agora para ver se
terminou o treino. E podemos ver isso.

Então começamos
com 33% de precisão. Mas à medida que passamos
pelas épocas– eu só fiz esta, eu
acho, por 15 épocas– ficou
cada vez mais preciso. Então, depois de 15 loops fazendo
isso, agora é 96,83% preciso. Como resultado, podemos ver,
usando essas técnicas, usando convoluções
como essa , conseguimos treinar
algo em apenas alguns minutos para ter aproximadamente 97% de precisão
na detecção de pedra, papel e tesoura.

E se eu fizer um
gráfico rápido aqui, podemos ver que este é um gráfico dessa precisão– a
linha vermelha mostrando a precisão onde começamos em aproximadamente 33%. E estamos chegando perto de 100%. A linha azul é que
tenho um conjunto de dados separado de pedra, papel e tesoura com o
qual testei, apenas para ver como está indo. E está bem perto. Eu preciso fazer um pouco
de trabalho para ajustá-lo. E eu posso realmente tentar
um exemplo para mostrar a você. Então eu vou fazer upload de um arquivo. Vou escolher um
arquivo do meu computador. Dei um belo nome a
esse arquivo de Paper, então você pode adivinhar que é um paper.

E se eu abrir isso
e fazer o upload, ele vai fazer o upload disso. E então vai
me dar uma saída. E a saída é 1, 0, 0. Então você pensa, ah,
entendi errado. Ele detectou que é uma pedra. Mas, na verdade, meus neurônios
aqui, com base nos rótulos, estão em ordem alfabética. Portanto, a ordem alfabética
seria papel, depois pedra e depois tesoura. Na verdade, classificou isso
corretamente, dando-me um 1. Então, na verdade, é um papel. E podemos tentar
outro aleatoriamente. Vou escolher um arquivo
da minha máquina. Vou escolher uma tesoura
e abri-la e executá-la. E, novamente, papel,
pedra, tesoura, então vemos isso realmente
classificado corretamente. Portanto, esta pasta de trabalho
está on-line, se você quiser baixá-la
e brincar com ela para classificar
você mesmo e ver como é fácil para você treinar
uma rede neural para fazer isso.

E depois de
ter esse modelo, você pode implementá-lo
em seus aplicativos e talvez jogar pedra,
papel e tesoura em seus aplicativos. Podemos voltar
aos slides, por favor? Então, só para mostrar rapidamente a
ideia de como as convoluções realmente ajudam você com uma imagem
, é assim que o modelo se parece quando o defini. E aqui no topo, pode
parecer um bug no começo, se você
não estiver acostumado a fazer isso. Mas no topo aqui– lembre-se,
dissemos que minha imagem está chegando em 150 x 150– na verdade está dizendo,
ei, vou distribuir uma imagem que é 148 x 148.

Alguém sabe por quê? É um bug? Não, não é um bug. OK. Então, a razão
é que se meu filtro for 3 x 3, para eu poder olhar
para um pixel, eu tenho que jogar– para eu começar
na imagem, eu tenho que começar um pixel e um
pixel abaixo para que ela tenha vizinhos. Como resultado, tenho que
descartar todos os pixels na parte superior, inferior
e em ambos os lados da minha imagem. Então estou perdendo um
pixel em todos os lados. Então, meu 150 x 150
se torna um 148 x 148. E então, quando juntei isso,
dividi cada um dos eixos pela metade. Portanto, torna-se 74 x 74. Então, na próxima iteração
, torna-se 36 x 36, depois 17 x 17 e depois 7 x 7. Então, se você pensar em
todas essas 150 imagens quadradas passando por
todas essas convoluções, elas aparecerão com
muitas pequenas coisas 7 x 7. E essas pequenas
coisas de 7 x 7 devem destacar um recurso– pode ser uma unha. Pode ser um polegar. Pode ser a forma de uma mão.

E então esses recursos que
vêm através das convoluções são passados ​​para
a rede neural que vimos anteriormente para
gerar esses parâmetros. E então, a partir desses
parâmetros, com sorte, seria um palpite, e
um palpite realmente preciso, sobre algo ser uma
pedra, um papel ou uma tesoura. Portanto, se você preferir um IDE em
vez de usar o Collab, também poderá fazer isso. Costumo gostar muito de usar o
PyCharm para meus desenvolvimentos. Algum fã do PyCharm
aqui, por interesse? Sim, legal. Muitos de vocês. Então, aqui está uma
captura de tela do PyCharm quando eu estava escrevendo essa coisa de pedra,
papel e tesoura antes de colá-la no Collab, onde
você pode executá-la no Collab.

Então PyCharm é
muito, muito bom. E você pode fazer coisas como
depuração passo a passo. Se pudermos mudar para a
máquina de demonstração por um momento. Agora, farei uma
demonstração rápida do PyCharm fazendo a depuração passo a passo. Então, aqui, podemos ver que estamos
no pedra, papel e tesoura. E, por exemplo,
se eu acertar o Debug, posso até definir pontos de interrupção.

Agora, tenho um
ponto de interrupção no meu código. Então posso começar a dar uma
olhada no que está acontecendo no meu código de rede neural. Aqui, é aqui que estou
pré-carregando os dados nele. E
posso avançar e fazer muita depuração
para realmente garantir que minha rede neural
esteja funcionando da maneira que desejo. É uma das
coisas que ouço muito dos desenvolvedores
quando eles começam com o
aprendizado de máquina é que, parece
que seus modelos são uma caixa preta. Você tem todo esse
código Python para treinar um modelo e precisa fazer
algumas suposições. Com o TensorFlow
sendo de código aberto, posso entrar
no código do TensorFlow no PyCharm, como estou
fazendo aqui, para ver como o treinamento está acontecendo,
para me ajudar a depurar meus modelos. E Karmel, mais tarde
, também vai mostrar como algo chamado
TensorBoard pode ser usado para depurar modelos. Podemos voltar
aos slides, por favor? Então, com isso em mente, começamos
a entender o que
são as redes neurais e o básico
"Olá, mundo!" código para dar uma olhada em como
podemos usar algo chamado convoluções.

E são algo que
parece muito complicado e muito difícil. Mas
quando você começar a usá-los , verá que eles são realmente
muito, muito fáceis de usar, principalmente para
classificação de imagens e textos. E vimos então como,
em apenas alguns minutos , conseguimos treinar
uma rede neural para poder reconhecer pedra, papel
e tesoura com 97%, 98% de precisão. Isso é só começar. Mas agora, para nos mostrar como
realmente estender a estrutura , torná-la real
e fazer coisas realmente legais e
com qualidade de produção, Karmel
vai compartilhar conosco. Obrigada. [APLAUSOS] KARMEL ALLISON: Oi. Então, levantem as mãos rapidamente
para quantos de vocês eram totalmente
novos e agora estão remando o mais rápido que podem
para manter a cabeça acima da água? Tudo bem, um bom número de vocês.

Vou examinar, agora,
algumas das ferramentas e recursos que o TensorFlow tem para levá-
lo desde quando você realmente tem seu modelo
até a produção. Não se preocupe, não
há teste no final. Então, para aqueles de vocês que estão apenas
tentando acompanhar agora, rastreie essas palavras,
guarde em algum lugar na sua cabeça
que tudo isso está disponível. Para o resto de
vocês que já tem um modelo e está procurando mais o
que pode fazer com ele, preste atenção agora. Tudo bem. Então Laurence passou por
um problema de classificação de imagens. Nos slides, adoramos
problemas de classificação de imagens, porque eles ficam
bem nos slides.

Mas talvez seus dados não sejam um
problema de classificação de imagem. E se você tiver
dados categóricos ou dados baseados em texto? O TensorFlow
fornece várias ferramentas que permitem pegar
diferentes tipos de dados e transformá-los
antes de carregá-los em um modelo de aprendizado de máquina. Em particular, por
exemplo, aqui, talvez tenhamos alguns
clickstreams de usuários, certo? E nós temos um ID de usuário. Agora, se alimentarmos isso diretamente
em um modelo de aprendizado profundo, nosso modelo esperaria que
isso fosse real e numérico.

E pode pensar que o usuário
número 125 tem alguma relação com o usuário 126, embora na
realidade isso não seja verdade. Portanto, precisamos ser capazes
de pegar dados como esses e transformá-los em dados
que nosso modelo possa entender. Então, como fazemos isso? Bem, no TensorFlow,
uma das ferramentas que usamos extensivamente dentro
do Google são as colunas de recursos. Essas são configurações
que permitem configurar transformações
nos dados de entrada. Então aqui, você pode ver que estamos
pegando nossa coluna categórica, ID do usuário, e estamos
dizendo, ei, esta é uma coluna categórica
quando passamos os dados para ela. E não queremos que o modelo a
use como uma coluna categórica. Queremos transformar isso,
nesse caso, em uma incorporação, certo? Então você poderia fazer uma
representação one-hot. Aqui, vamos fazer uma
incorporação que realmente é aprendida conforme treinamos nosso modelo. Essa incorporação e outras colunas
que você possui podem ser alimentadas diretamente nas camadas do Keras.

Então, aqui, temos uma
camada de recursos densos que fará todas
essas transformações e as executará quando
passarmos nossos dados. E isso alimenta diretamente
nosso modelo Keras para que, quando passamos os
dados de entrada, as transformações
aconteçam antes de realmente começarmos a aprender com os dados. E isso garante
que nosso modelo aprenda o que queremos
, usando dados numéricos de valor real. E o que você
faz com essa camada depois de
colocá-la em seu modelo? Bem, em Keras,
fornecemos algumas camadas. Laurence falou com você através de
camadas convolucionais, agrupando camadas. Esses são alguns dos
mais populares em modelos de imagem. Mas temos
uma série de camadas, dependendo de quais são
suas necessidades– tantas que eu não poderia encaixá-las
em uma única captura de tela aqui.

Mas existem RNNs,
camadas de abandono, norma de lote, todos os tipos
de camadas de amostragem. Portanto, não importa que
tipo de arquitetura você esteja construindo,
se está construindo algo para seu próprio caso de uso pequeno
e modelo de classificação de imagem, seja ele qual for, ou o mais recente
e melhor modelo de pesquisa, há
várias camadas integradas que vão tornar
isso muito mais fácil para você. E se você tem um
caso de uso personalizado que não está realmente representado em
uma das camadas, e talvez você tenha
algoritmos personalizados ou funcionalidade personalizada, uma
das belezas do Keras é que ele
facilita a criação de subclasses de camadas sua
própria funcionalidade.

Aqui, temos uma
camada de normalização de Poincaré. Isso representa uma
incorporação de Poincaré. Isso não é fornecido
pronto para uso com o TensorFlow, mas um membro da comunidade
contribuiu com essa camada para o
repositório de complementos do TensorFlow, onde fornecemos várias
camadas de casos de uso especiais personalizados. É útil, se você
precisar de normalização Poincaré, mas também um exemplo muito bom
de como você pode escrever uma camada personalizada para lidar com
todas as suas necessidades, se não tivermos isso
pronto para uso para você. Aqui, você escreve o
método de chamada, que lida com o avanço dessa camada. Portanto, você pode conferir o
repositório de complementos do TensorFlow para obter mais exemplos
de camadas como esta.

Na verdade, tudo em
Keras pode ser subclassificado, ou quase tudo. Você tem métricas,
perdas, otimizadores. Se você precisa de uma funcionalidade que
não é fornecida pronta para uso, tentamos facilitar
a criação com base no que o Keras já oferece, enquanto ainda
aproveitamos todo o ecossistema Keras e TensorFlow. Então, aqui, estou
subclassificando um modelo. Portanto, se eu precisar de algum
encaminhamento personalizado em meu modelo, posso fazer isso
facilmente no método de chamada.

E posso definir
loops de treinamento personalizados em meu modelo personalizado. Isso facilita fazer–
neste caso, uma coisa trivial, como multiplicar por um número mágico. Mas para muitos
modelos em que você precisa fazer algo
diferente do loop de ajuste padrão, você pode
personalizar dessa maneira e ainda
aproveitar todas as ferramentas que fornecemos para o Keras. Portanto, um dos problemas
com modelos personalizados e modelos mais complicados
é que é difícil saber se
você está realmente fazendo o que
pensa que está fazendo e se seu
modelo está treinando. Uma das ferramentas que fornecemos
para Keras e TensorFlow de forma mais ampla é o TensorBoard. Esta é uma ferramenta de visualização. É baseado na web
e executa um servidor que receberá os
dados conforme seu modelo treina, para que você possa ver em
tempo real, época por época ou passo a passo, como
seu modelo está se saindo. Aqui, você pode ver a precisão
e a perda à medida que o modelo treina e converge.

E isso permite que você acompanhe
seu modelo enquanto treina e garante que está
realmente progredindo em direção à convergência. E quando você está usando o
Keras, também pode ver que obtém o gráfico completo
das camadas que você usou. Você pode se aprofundar neles e
realmente obter o gráfico de nível operacional no TensorFlow. E isso é muito útil
na depuração, para garantir que você
conectou seu modelo corretamente e está realmente
construindo e treinando o que acha que está treinando. No Keras, a maneira como
você adiciona isso é tão fácil quanto algumas linhas de código. Aqui, temos nosso
retorno de chamada do TensorBoard que definimos. Adicionamos isso ao nosso
modelo durante o treinamento. E isso vai
gravar nos logs, no disco,
várias métricas diferentes que são lidas pela
GUI da Web do TensorBoard. E como um bônus adicional, você
obtém perfis de desempenho integrados com isso. Portanto, uma das guias
no TensorBoard mostrará
onde todas as suas operações estão sendo colocadas, onde você
tem gargalos de desempenho.

Isso é extremamente
útil quando você começa a construir modelos maiores e em maior
número, pois verá que o desempenho
durante o treinamento pode se tornar um dos
gargalos do seu processo. E você realmente
quer fazer isso mais rápido. Falando em desempenho,
este é um gráfico de quanto tempo leva para o ResNet-50,
um dos modelos de aprendizado de máquina mais populares
para classificação de imagens , treinar usando uma GPU. Nem pergunte quanto
tempo leva com uma CPU, porque ninguém gosta
de sentar e esperar até que termine.

Mas você pode ver
que leva quase uma semana com uma GPU. Uma das belezas
do aprendizado profundo é que ele é
facilmente paralelizável. E então, o que queremos
fornecer como TensorFlow são maneiras de pegar esse
pipeline de treinamento e paralelizá-lo. A maneira como fazemos isso no
TensorFlow 2.0 é fornecer uma série de
estratégias de distribuição. Isso
facilitará muito a obtenção do código do modelo existente. Aqui, temos um
modelo Keras que se parece com muitos
dos outros que você viu ao longo desta palestra. E vamos distribuí-
lo por várias GPUs. Aqui, adicionamos a
estratégia espelhada. Com essas poucas
linhas de código, agora podemos distribuir nosso
modelo em várias GPUs. Essas estratégias foram
projetadas desde o início para serem fáceis de usar e
escalonáveis ​​com muitas arquiteturas diferentes e para
oferecer excelente desempenho imediato. Então, o que isso realmente está fazendo– aqui, você pode ver que com
essas poucas linhas de código, ao construir nosso modelo sob o
escopo da estratégia, o que fizemos foi pegar o modelo
, copiá-lo em todos de nossos diferentes dispositivos.

Nesta imagem,
digamos que temos quatro GPUs. Copiamos nosso modelo
nessas GPUs e fragmentamos os dados de entrada. Isso significa que
você realmente processará a
entrada em paralelo em cada um dos seus
diferentes dispositivos. Dessa forma,
você pode dimensionar o treinamento do modelo de forma aproximadamente
linear com o número de dispositivos que possui. Portanto, se você tiver quatro GPUs,
poderá executar aproximadamente quatro vezes mais rápido. O que isso acaba
parecendo– na ResNet, você pode ver que
temos um ótimo dimensionamento. E pronto para uso, o
que você obtém com isso é que suas variáveis ​​são
espelhadas e sincronizadas em todos os dispositivos disponíveis. Os lotes estão sendo pré-buscados. Tudo isso serve para
tornar seus modelos muito mais eficientes durante o
tempo de treinamento, tudo sem alterar o código quando você estiver usando o Keras. Tudo bem. E a estratégia espelhada com várias
GPUs é apenas o começo. Ao dimensionar modelos, como
fazemos no Google, por exemplo, talvez você queira usar vários
nós e vários servidores, cada um com
seu próprio conjunto de GPUs. Você pode usar a
estratégia de espelhamento multiworker para isso, que
vai pegar seu modelo, replicá-lo em
várias máquinas, todas trabalhando de forma síncrona
para treinar seu modelo, espelhando variáveis
em todas elas.

Isso permite que você treine seu
modelo mais rápido do que nunca. E essa API
ainda é experimental, pois estamos desenvolvendo. Mas no TensorFlow 2.0, você poderá executar isso pronto para uso
e obter um ótimo desempenho
em clusters de grande escala. Tudo bem. Portanto, tudo o que
falei até agora se enquadra nos
modelos de treinamento. E você descobrirá
que muitos construtores de modelos só pensam
na parte de treinamento. Mas se você tem um
modelo de aprendizado de máquina que está tentando
colocar em produção , sabe que isso é
apenas metade da história. Há toda uma outra
metade, que é, bem, como faço para pegar o que
aprendi e realmente servir isso aos clientes ou a
quem quer que seja o usuário final, certo? No TensorFlow, a maneira
como fazemos isso é que você terá que serializar
seu modelo em um modelo salvo.

Esse modelo salvo se torna o
formato serializado do seu modelo que se integra
ao restante do ecossistema do TensorFlow . Isso permite que você implante
esse modelo na produção. Por exemplo, temos
várias bibliotecas e utilitários diferentes que
podem usar esse modelo salvo. Para o TensorFlow
Serving, poderemos pegar
esse modelo e fazer solicitações de serviço baseadas na web. Isso é o que usamos no Google
para alguns de nossos sistemas de maior escala. TensorFlow Lite é para
desenvolvimento móvel. O TensorFlow.js é uma
solução nativa da Web para servir seus modelos.

Não
terei tempo de abordar tudo isso nos
próximos minutos, mas falarei um pouco mais sobre o TensorFlow
Serving e o TensorFlow Lite . Mas primeiro, como você
realmente chega a um modelo salvo? Novamente, no TensorFlow 2.0,
isso será fácil e pronto para uso
, onde você usará seu modelo Keras, você chama .save. E isso vai
gravar o formato de modelo salvo do TensorFlow . Esta é uma
versão serializada do seu modelo. Ele inclui o gráfico inteiro
, todas as variáveis, pesos e tudo o
que você aprendeu, e grava isso no
disco para que você possa pegá-lo, passá-lo para outra
pessoa, digamos. Você pode carregá-lo de
volta no Python. Você receberá todo o
estado do objeto Python de volta, como pode ver aqui.

E você pode continuar
treinando, continuar usando isso. Você pode ajustar com
base nisso. Ou você pode pegar esse modelo
e carregá-lo no TF Serving. Portanto, o TensorFlow Serving responde
a solicitações gRPC ou REST. Ele atua como um front-end
que recebe as solicitações e as envia ao seu
modelo para inferência. Ele vai
trazer o resultado de volta. Portanto, se você estiver criando um
aplicativo da Web para nosso jogo de pedra, papel e tesoura,
poderá tirar uma foto e enviá-la ao seu servidor. O servidor vai perguntar
ao modelo, ei, o que é isso? Envie de volta a resposta, com base
no que o modelo encontrou. E dessa forma, você consegue
aquela viagem de ida e volta completa.

O TensorFlow Serving é
o que usamos internamente para muitos dos nossos maiores
modelos de aprendizado de máquina. Por isso, foi otimizado para
ter baixa latência e alta taxa de transferência. Você pode conferir
em TensorFlow.org. Há todo um conjunto
de componentes de pipeline e processamento de produção
que chamamos de TensorFlow Extended ou TFX. Você pode aprender mais sobre
eles em TensorFlow.org, usando aquele prático
código QR bem ali. E talvez você tenha um modelo
e seu aplicativo da web. Mas realmente, você quer
isso em um telefone, certo? Porque o futuro é móvel. Você quer
poder levar isso para qualquer lugar. Portanto, o TensorFlow Lite
é a biblioteca que fornecemos para converter
seu modelo salvo em um tamanho muito pequeno. Para que possa caber no
seu dispositivo móvel.

Pode caber em dispositivos incorporados – Raspberry Pis, Edge TPUs. Agora, executamos esses modelos
em vários dispositivos diferentes. A maneira de fazer isso é
pegar o mesmo modelo salvo do mesmo código de modelo
que você escreveu originalmente. Você usa o conversor TF Lite
, que diminui a pegada desse modelo. E então pode ser carregado
diretamente no dispositivo. E isso permite rodar
no próprio aparelho, sem internet, sem servidor em
segundo plano, seja qual for o seu modelo. E você pode
levar, levar o TensorFlow, para onde você quiser. Agora, percorremos,
muito rapidamente, desde alguns
fundamentos do aprendizado de máquina, passando pela construção de seu
primeiro modelo, até algumas das
ferramentas que o TensorFlow fornece para pegá-los e
implantá-los na produção.

O que você faz agora? Bem, há
muito mais por aí. Você pode ir para google.dev. Você pode acessar
TensorFlow.org, onde temos um grande
número de tutoriais. Você pode acessar o GitHub. Tudo isso é código aberto. Você pode ver as diferentes
bibliotecas lá, fazer perguntas, enviar PRs. Nós amamos PRs. E com isso, eu
gostaria de dizer, obrigado. LAURENCE MORONEY:
Muito obrigado. KARMEL ALLISON:
Laurence, volte atrás. [APLAUSOS] [MÚSICA TOCANDO].

Texto inspirado em publicação no YouTube.

Quer Saber Muito Mais? Venha para a MIND21 Educação