A primeira REDE NEURAL PROFUNDA🤖: Perceptron Multicamada 🦿 | Redes Neurais e Deep Learning 06

[@kymiekymi2052]

Muito bom mesmo!!! Parabéns pelo trabalho exposto.

[@UniversoDiscreto]

Muitíssimo obrigado

[@joseyrikes9686]

melhor conteúdo do youtube sobre redes neurais com toda a certeza

[@arthurbaia1215]

Seus videos são excelentes Lucas, muito obrigado por disponibliza-los no yt.

[@MateusPedro-k2f]

Amei a tua aula, logo do princípio, és excelentíssimo.

[@pedrogomeshipnose]

Nem assisti ao vídeo ainda, mas já dei like só pela organização da descrição, parabéns.
Dito isso, agora vou assistir rsrs

[@jonasoliveira1143]

Cê tá de brincadeira comigo! hahaha
Eu tô em choque com a coincidência!
Eu estava aqui fazendo meu trabalho de neurocomputação de boa, aí chegou a notificação do canal, pensei - "vô conferir".
Resumo da ópera, eu tô aplicando MLP nesse dataset NESTE momento! hahahaha

[@UniversoDiscreto]

hahahahahahaha tá brincando
dá um oi pra câmera, estou te vigiando =P

[@MariaEduardaAlvesBarnabe]

Cara! Tu me ajudou muito no meu tcc. Muito bom!

[@LeviSoares-m1i]

Que aula show

[@carloscosta4713]

Parabéns pelo belíssimo trabalho. Mais um inscrito no canal!!!

[@cronosbr887]

Vídeo excelente cara, muito obrigado! Me ajudou muito com o trabalho da faculdade e sua didática é foda man, parabéns!

[@Aprendendopontocom]

Parabéns pelo ótimo trabalho!

[@miltonborges7356]

excelente

[@combathaker]

Obrigado sempre pela disposição de passar conhecimento, sempre ajuda muito essas aulas em português ainda.

[@ronpdf2084]

show de bola. otimas explicaçoes!

[@Marcelo-tz6du]

gosto muito de ver vídeos programando, ajuda muito

[@blancasosa9352]

Muito obrigada pelo seu video!!! nunca pensei que ia encontrar um material assim, explicado, por um Prof. Dr. assim de maneira detalhada e com base matemática. e Python. Parabens!! y muito obrigada, Obrigada Universo Discreto, abriu minha mente e uniu o que queria unir. Tudo de bom!! sim, vou enviar um presentinho, muito legal, de outras culturas. Valeu!!! Dr. Lucas

[@UniversoDiscreto]

Obrigado pelo carinho =)

[@CalangoBit]

Ótimas explicações! Obrigado!

[@vick-santoss]

Excelente aula! 👏🏼👏🏼

[@fillescoladeroboticistascu8100]

Parabéns pelos vídeos!

[@renandomingues2279]

muito obrigado! ajudou mto de verdade.

[@jeffersonferreira43]

aula boa, passa e você nem percebe que se foram uma hora

[@rodrigotrindade5026]

Posso estar enganado. Mas acredito que o z-score não normaliza os dados. A propósito, excelente aula.

[@holandonhdunto6808]

Qual e a diferença da rede mult perceptron e rede neural deep learning, to com uma duvida, ja que dizem que a mult perceptron tem um bug chato da rede explodir produzir numeros infinitos e tambem parar de treinar por calsa da derivada que reduz o valor e suporta no maximo 3 camadas. E pelo que vejo rede mult percepron parece ser identica a deep learning.

[@fabianosantana2357]

Muito boa sua colocação, neste caso utilizamos o perceptron multicamada(pm) no final, e antes o deep learning utilizando redes convolucionais e em seguida, redes de aglutinação, aí então o pm. Caso não utilizemos as rc e ra, o valor dos pesos serão estratosféricos, um exemplo: imagine 3 camadas de 784 neurônios é uma camada de saída de 10 neurônios (784x784x784x784x10=3.778.019.983.360 pesos)

[@holandonhdunto6808]

@@fabianosantana2357 É imagina uma rede desse tamanho, acho que nunca iria aprender porque iria torrar o computador antes, eu tentei fazer uma rede do zero com java script e o maior problema além da instabilidade e a taxa de aprendizagem, se a taxa for alta de mais a rede explode e se for baixa de mais a rede demora a calcular, basicamente para tentar contornar esse problema acabei reduzindo uma fração da taxa de aprendizagem a cada explosão, e reiniciava o calculo do zero.
Exemplo uma rede para XNOR com 2 camadas ocultas:
def LRelu(value):
return max(value,value*0.1)
def Linear(value):
return value
def Rede(input):
x = input
camada1 = [0,0]
camada2 = [0]
camada1[0] = LRelu((x[0] * 1.1963943945988964)+(x[1] * -2.2891299183900764)+(2.289161325669511))
camada1[1] = LRelu((x[0] * 1.9394895637234917)+(x[1] * -2.9188329706549516)+(0.9876820266284383))
camada2[0] = Linear((camada1[0] * -1.0132227616638183)+(camada1[1] * 1.1321663282856993)+(1.2088385065264189))
return camada2
Ou uma rede para XNOR com 5 camadas ocultas de 3 neuronio:
def Rede(input):
x = input
camada1 = [0,0,0]
camada2 = [0,0,0]
camada3 = [0,0,0]
camada4 = [0,0,0]
camada5 = [0,0,0]
camada6 = [0]
camada1[0] = LRelu((x[0] * 1.1448775840076473)+(x[1] * -1.6078377130925017)+(0.8580728088182978))
camada1[1] = LRelu((x[0] * 0.9095601211199668)+(x[1] * -0.13113147028744954)+(0.20678793069539747))
camada1[2] = LRelu((x[0] * 0.858452652774856)+(x[1] * -0.1742875863748043)+(0.143477742195115))
camada2[0] = LRelu((camada1[0] * 1.3571346012179406)+(camada1[1] * 0.28788669372152764)+(camada1[2] * 0.32966402167270775)+(0.2189920214785659))
camada2[1] = LRelu((camada1[0] * 1.3948793429346353)+(camada1[1] * 0.33977692856111774)+(camada1[2] * 0.4563666484630919)+(0.668967834856637))
camada2[2] = LRelu((camada1[0] * 0.7875668681125051)+(camada1[1] * 0.12124747511736403)+(camada1[2] * 0.05896550436311628)+(0.4315459176940251))
camada3[0] = LRelu((camada2[0] * 0.9623654690547646)+(camada2[1] * 0.8835370514579622)+(camada2[2] * 0.6599944635416627)+(0.44527218166575583))
camada3[1] = LRelu((camada2[0] * 0.5195099529345267)+(camada2[1] * 0.4931599527332543)+(camada2[2] * 0.8920050262671944)+(0.3483627688439634))
camada3[2] = LRelu((camada2[0] * 0.7671883403490718)+(camada2[1] * 0.770689186561994)+(camada2[2] * 0.29776960093323757)+(0.131897270886586))
camada4[0] = LRelu((camada3[0] * 0.6315310037621974)+(camada3[1] * 0.7046785709687089)+(camada3[2] * 0.7298628229341767)+(0.4800946629198886))
camada4[1] = LRelu((camada3[0] * 0.6820750072456667)+(camada3[1] * 0.24656189848605348)+(camada3[2] * 1.0701771934096351)+(0.01752137400543766))
camada4[2] = LRelu((camada3[0] * 0.33469851430601194)+(camada3[1] * 0.8214021697073297)+(camada3[2] * 0.7310812292898901)+(0.2619497826884738))
camada5[0] = LRelu((camada4[0] * 0.5186805609082911)+(camada4[1] * 0.7214649544620108)+(camada4[2] * 0.2722611060811708)+(0.19205678763422626))
camada5[1] = LRelu((camada4[0] * 0.1544245374648939)+(camada4[1] * -0.3325195850026798)+(camada4[2] * -0.08244660586604363)+(1.6333353757497115))
camada5[2] = LRelu((camada4[0] * 0.8751096656558327)+(camada4[1] * 1.0633026573905286)+(camada4[2] * 0.3835623963055925)+(0.22115677022272492))
camada6[0] = Linear((camada5[0] * 0.036113637599298344)+(camada5[1] * 1.5157816886408022)+(camada5[2] * 0.04758158764759078)+(-1.195980937412686))
return camada6

[@fabianosantana2357]

@@holandonhdunto6808 isso é fascinante naum? Parabéns pelo trabalho

[@Marcelo-tz6du]

eu queria saber apenas uma dúvida, se eu quiser ler uma tabela nova que pode ter valores um pouco diferente da original, o standardscaler vai transformar ele baseado nos dados antigos ou apenas aplicar a função novamente neles?

[@UniversoDiscreto]

se eu entendi bem sua pergunta, pra cada base de dados nova vc precisa aplicar o fit_transform() de novo. ele "treina" um objeto capaz de normalizar os dados. o objeto StandardScaler() pode até ser o mesmo, não precisa instanciar um novo não

[@Marcelo-tz6du]

@@UniversoDiscreto era basicamente isso mesmo, mesmo que o treinamento e a base nova tenham valores muito diferentes, a mudança vai surgir pouco efeito? Exemplo, no meu teste eu testei com taxas que variam entre 150 a 50, mas nos novos dados eles estão entre 500 a 400, ainda assim essa diferença após normalizar vai ser minimizada?:

[@UniversoDiscreto]

@@Marcelo-tz6du eu não entendi oq vc chamou de taxa. São os valores da base de dados? As colunas do dataframe?

[@Marcelo-tz6du]

Sim, são os valores da coluna, mas com valores bem diferentes entre dados de teste e o novo dado para previsão

[@UniversoDiscreto]

@@Marcelo-tz6du os valores podem variar bastante pois ele "zera" em relação a média. É uma conta que envolve subtrair pela média e dividir pela variância cada amostra, algo assim. E o train test split ainda "embaralha" as amostras, podendo mudar MT o teste e treino

[@giovanniformaggio1789]

o algoritmo do backpropagation foi criado em 1974 por PAUL J. WERBOS e não em 1986.

[@joaobalieiro6264]

Excelente vídeo. Quando eu ficar rico com ML mando um puta pix pra vc. Uma pergunta: Como a rede calcula a acurácia durante o treinamento se vc não deu o limiar onde ele escolhe 0 ou 1 para o output?

[@UniversoDiscreto]

Tudo jóia? Obrigado! Se puder assistir os vídeos quando saírem e comentar, já ajuda muito.
Sobre a pergunta, geralmente é usado o limiar padrão de 0,5. A saída de uma rede neural como essa do vídeo é uma probabilidade entre zero e um. A acurácia é calculada em cima disso, considerando esse limiar padrão.
Abraço!

[@joaobalieiro6264]

@@UniversoDiscreto já virei fã de carteirinha do canal. Vou comentar e curtir sempre que possível. Obrigado pela resposta ❤️❤️

[@Toda_Ciencia]

quero ver quem deu esse 1 dislike!!!

[@TaniaBorgesBarros.Escritora]

🤍🇨🇭🇧🇷