YT YouTube2Text

YouTube2Text → Transcripts → Gradiente Descendente Paso a Paso con Python: Un Algoritmo de Optimización para Machine Learning

Gradiente Descendente Paso a Paso con Python: Un Algoritmo de Optimización para Machine Learning — Transcript

by Codigo Maquina · 8,454 words · 1,324 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00en la vida cotidiana comunmente
0:02intentamos optimizar por ejemplo
0:05intentamos realizar la mayor cantidad de
0:08actividades en el menor tiempo posible
0:12claro para lograr esto nosotros tenemos
0:14que hacer múltiples ajustes algo muy
0:17similar pasa dentro del contexto de
0:20aprendizaje de máquina las diferentes
0:22técnicas que nosotros utilizamos para
0:25predecir o para clasificar
0:26automáticamente
0:28tienen que ajustar sus parámetros para
0:32poder realizar esta actividad con el
0:35menor error posible claro está cada una
0:39de estas técnicas tiene su propia manera
0:41de optimizar sus parámetros de
0:44ajustarlos de forma que puedan predecir
0:47o clasificar con el menor error posible
0:50sin embargo existe un algoritmo de
0:54optimización que es muy relevante y muy
0:57utilizado y que es la base para entender
1:01muchas de las técnicas no solo de
1:04aprendizaje de máquina sino de
1:07aprendizaje de máquina profundo está
1:10técnica de optimización se llama el
1:12gradiente descendiente en este vídeo
1:16nosotros visualizaremos cómo funciona
1:19este algoritmo lo veremos paso a paso de
1:24hecho les comento realizaremos algunos
1:27cálculos sin embargo estos cálculos
1:29nosotros los realizaremos vía
1:32programación dado que estamos en un
1:35canal de programación mi nombre es
1:37octavio gutiérrez y en este canal
1:39aprenderemos programación inteligencia
1:42artificial y aprendizaje de máquina
1:43gracias por acompañarme
1:46[Música]
1:50vamos a iniciar la explicación del
1:52algoritmo descendiente utilizando un
1:53contexto un poco extraño sin embargo ya
1:56verán este contexto nos ayudará
1:58muchísimo a entender a groso modo cómo
2:02funciona este algoritmo ok la imagen que
2:05nosotros estamos viendo aquí es una
2:08imagen de una zona montañosa y la
2:11estamos viendo grises y está porque se
2:13asume que está de noche pero de esas
2:15noches que no ves absolutamente nada y
2:18en el fondo de estas zonas montañosas en
2:20la parte más baja se encuentra un arroyo
2:23y este arroyo lleva una corriente muy
2:28baja ok entonces ahora imaginemos que
2:32vamos en un avión 10 y se queda
2:34completamente extraño pero bueno síganme
2:35aquí vamos en este avión y nosotros
2:39queremos llegar al arroyo entonces pues
2:43no hay manera de que nosotros
2:44aterrizamos el avión nos lanzamos con un
2:46paracaídas
2:48podríamos caer aquí obviamente lanzarse
2:52con paracaídas salvo que se hace un
2:53experto pues no hay una manera así tan
2:56fácil de garantizar donde caer pero
2:58estás en una zona montañosa pero también
3:01pudimos haber caído por acá o pudimos
3:03haber caído por acá o pudimos haber
3:05caído en diferentes posiciones sin
3:08embargo cómo le hacemos si no traemos
3:12nosotros una lámpara para llegar a donde
3:15se encuentra el arroyo no tiene una
3:17corriente entonces no lo podemos
3:18escuchar está enteramente oscuro
3:21entonces no podemos ver pero estamos en
3:24una zona montañosa y sabemos que en el
3:26fondo se encuentra el arroyo entonces
3:30como llego yo al arroyo como llego yo al
3:33fondo asumamos que una vez que caemos
3:37dado que no podemos ni escuchar ni ver
3:40simplemente estamos un paso exploratorio
3:43hacia adelante y otro hacia atrás otro
3:45hacia la izquierda y otro hacia la
3:47derecha y nosotros vemos cuál de estos
3:50pasos nos lleva al fondo cuál de estos
3:54decae más y vamos a suponer que fue el
3:59paso hacia adelante entonces todo en mi
4:02paso y una vez que doy el paso
4:04nuevamente
4:06exploro porque la superficie podría ser
4:10irregular entonces vuelvo a dar un paso
4:13hacia adelante un paso hacia atrás un
4:15paso hacia la derecha y determinó cuál
4:19de estos pasos me lleva más hacia el
4:22fondo y ya se imaginarán podemos hacer
4:25exactamente el mismo procedimiento hasta
4:29que lleguemos al arroyo hasta que
4:31toquemos el agua y esto es gracias a que
4:34sabemos que el arroyo se encuentra justo
4:37en el fondo sin embargo qué pasa si lo
4:40trasladamos a una técnica de aprendizaje
4:43de máquina nosotros poco a poco
4:47utilizando una cierta dirección vamos
4:50ajustando los parámetros y nos vamos
4:54ajustando con el objetivo de llegar al
4:56fondo al fondo de que al fondo de una
4:59función de error donde una función de
5:02error se hace cero o se encuentra en la
5:05posición más baja y con esto yo habré
5:09logrado la optimización de ese parámetro
5:12y por tanto podría predecir o clasificar
5:16con el menor error posible ok podemos
5:20ver claramente por qué se le llama
5:22descendiente a este algoritmo sin
5:25embargo la parte de gradiente que es el
5:28gradiente el gradiente es justo la
5:31dirección y la magnitud con la cual
5:34nosotros tenemos que dar este paso
5:37matemáticamente qué significa cómo
5:40calculamos un gradiente lo calculamos
5:43utilizando derivadas pero en este punto
5:46no se me asusten las vamos a calcular
5:50utilizando python simbólico una librería
5:53que se llama simple no obstante aquí lo
5:56más importante es entender qué es lo que
6:00estamos haciendo con la derivada
6:02y va a ser muy fácil porque lo
6:06visualizaremos de hecho aquí permítanme
6:09mostrarles las diferentes
6:11visualizaciones que nosotros veremos a
6:14lo largo de este vídeo debo mencionar
6:17aquí veremos mucho código de
6:20visualización sin embargo no le vamos a
6:22dar énfasis en la enseñanza de la
6:24visualización para eso ya tenemos una
6:27playlist dentro de este canal que aquí
6:29arriba les dejo el vínculo recuerden
6:32estamos en un canal formativo de hecho
6:36tenemos justo un vídeo desde la
6:39instalación de payton para que nosotros
6:42podamos construir de una forma
6:45incremental paso a paso nuestra
6:48formación y el aprendizaje de máquina
6:51ok ahora sí ya estamos listos para irnos
6:55a la programación del algoritmo del
6:58gradiente descendiente vamos al código
7:01dentro de nuestra libreta de
7:04el algoritmo del gradiente descendiente
7:07es una técnica de
7:08optimización sin embargo nosotros que
7:11vamos a optimizar vamos a optimizar los
7:14parámetros de una regresión lineal de un
7:18modelo de regresión lineal quise
7:21seleccionar esta técnica de aprendizaje
7:23de máquina tal vez una de las más
7:26sencillas para tratar de simplificar lo
7:30más posible la explicación del gradiente
7:33descendiente sin embargo si alguien en
7:36este punto no está familiarizado con la
7:39técnica de regresión lineal aquí arriba
7:41les dejo un vídeo que podrían consultar
7:44podrían en este punto y sea a ver ese
7:47vídeo y después regresar no obstante no
7:50es enteramente necesario porque lo vamos
7:53a explicar
7:54rápidamente ok ahora permítanme ver las
7:58diferentes librerías que vamos a
8:00utilizar a lo largo de este vídeo vamos
8:04a utilizar un pactado que estamos
8:05trabajando con vectores vamos a utilizar
8:08más los lic porque ya vimos vamos a
8:10generar mucho de hecho muy bonitas vamos
8:13a utilizar la liberalidad de sim para
8:15que nos va a permitir hacer derivadas y
8:18derivadas parciales de una forma
8:20bastante sencilla donde nosotros nos
8:23podemos enfocar justo en su
8:26interpretación y no en cómo hacer una
8:30derivada y posteriormente utilizaremos
8:33hitler una de las librerías más
8:35utilizadas dentro del contexto de
8:37aprendizaje de máquina cuando se
8:40programa con python pero aquí está
8:43alquiler no para justo utilizar un
8:47algoritmo de gradiente descendiente que
8:49ya viene implementado ahí sino para
8:52generar el modelo de regresión lineal a
8:55través del método de mínimos cuadrados
8:57que es el método de optimización que
9:00justo utiliza la técnica de revisión
9:03lineal para calcular sus parámetros
9:05entonces nosotros vamos a calcular él
9:09óptimo donde la función de error llega
9:12hasta el fondo utilizando el gradiente
9:15descendiente pero para que sepamos que
9:18lo estamos haciendo de la manera
9:20correcta de la manera apropiada pues
9:23vamos a agarrar como referencia a que el
9:27algoritmo que ya tiene implementado sanz
9:30killer para este tipo de modelos ok
9:33entonces vamos a tener ahora otro
9:36contexto una variable independiente
9:38donde vamos a tener los años de
9:41experiencia de justo tres personas una
9:45persona que tiene 5 años 6 años y otra
9:47que tiene 13 años de experiencia y para
9:50cada una de ellas vamos a tener un
9:53salario que va a ser nuestra variable
9:56objetivo aquella variable que nosotros
9:57queremos predecir en función del número
10:00de años de experiencia laboral
10:03nosotros queremos determinar cuál sería
10:06el salario de esa persona en este caso
10:09tenemos una persona que tiene 5 años de
10:11experiencia y que aproximadamente gana 6
10:15punto 85 miles de pesos y tenemos una
10:19persona que tiene 6 años de experiencia
10:21y que aproximadamente gana
10:2316.83 miles de pesos estos datos están
10:28en miles de pesos y por último obtenemos
10:31una tercera persona que tiene 13 años de
10:35experiencia y su salario equivale a
10:3826.84 miles de pesos y con esto
10:43generamos el modelo de regresión lineal
10:47utilizando justo la librería de esa
10:50killer recuerden si quieren ver detalles
10:52de cómo crear lo utilizan 2 alquiler
10:55aquí arriba en el vídeo que les dejo ahí
10:57lo pueden consultar aquí simplemente lo
10:59vamos a crear lo está creando utilizando
11:03una técnica que se llama el método de
11:05mínimos cuadrados ok entonces nosotros
11:08ya generamos nuestro modelo que como es
11:10lineal no es otra cosa más que una
11:11simple línea recta
11:15aquí tenemos código de
11:19visualización y en este caso simplemente
11:22vamos a ejecutar
11:25aquí está vean que gráfica tan bonita
11:27nos está generando
11:28y qué es lo que tenemos nosotros estos
11:33datos en amarillo son justo los datos
11:37los valores verdaderos que nos sirvieron
11:39de base para crear nuestro modelo en
11:42este caso tenemos aquí la persona de 5
11:44años de experiencia ganando un salario
11:47de hecho déjenme verificar
11:506.85 aquí está más o menos 6.85 y acá
11:55tenemos la persona que tiene 13 años de
11:58experiencia aproximadamente ganando 27
12:00mil pesos ok y acá tenemos a la segunda
12:04persona y con estos tres datos nosotros
12:06creamos una línea un modelo es este
12:10modelo que está aquí ese está en línea
12:12rosa que nosotros tenemos y con este
12:15modelo nosotros podemos ahora sí
12:18realizar predicciones de cuánto ganaría
12:21una persona en función de los años de
12:24experiencia por ejemplo aquí tenemos que
12:26una persona de aproximadamente ocho años
12:29de experiencia podría ganar
12:32según este modelo aproximadamente 17 mil
12:36pesos ok este es nuestro modelo
12:38obviamente este modelo no es perfecto
12:41porque no es perfecto porque hay un
12:44error para la persona que tiene 5 años
12:46de experiencia el valor real la zona
12:49aproximadamente 6 mil pesos sin embargo
12:51que nos está diciendo a nuestro modelo
12:53nuestro modelo nos está diciendo que una
12:56persona de 5 años de experiencia
12:58aproximadamente gana 11 mil pesos y que
13:01nos está diciendo
13:02para una persona de 6 años de
13:05experiencia que aproximadamente gana 13
13:07mil pesos pero nuestros datos reales nos
13:10están diciendo que son 17 mil pesos más
13:12o menos y cuando llegamos a una persona
13:15que tiene 13 años de experiencia aquí el
13:18error no es tan grande sin embargo si
13:21hay un error a estos errores se les
13:23llama residuos y una métrica para
13:27determinar el error de un modelo de
13:30regresión es justo tomar en cuenta este
13:34error más este error más este error y
13:37elevarlo al cuadrado se eleva al
13:39cuadrado simplemente para quitar el
13:41signo porque acá podría ser un signo
13:43positivo y acá podría ser un signo
13:45negativo un error hacia arriba un error
13:47hacia abajo entonces lo elevamos al
13:49cuadrado el otro objetivo de elevarlo
13:51hasta el cuadrado es darle mayor
13:53importancia a los errores más grandes
13:55que a los errores pequeños ya tenemos en
13:58este canal un vídeo explicando las
14:01diferentes métricas para evaluación de
14:03modelos de regresión y ahí explicamos
14:06justo esta métrica que por sus siglas en
14:09inglés se llama rss que es simplemente
14:12la suma de los residuos al cuadrado
14:14recuerden que es un residuo este es un
14:16residuo este es un residuo este es un
14:18residuo lo sumamos pero cada uno lo
14:20elevamos al cuadrado ok entonces ya
14:24tenemos una manera de determinar el
14:26error porque estoy hablando muchísimo
14:28del error porque con el error nosotros
14:31podemos construir nuestra zona montañosa
14:34podemos construir el error y donde esté
14:36más al fondo donde esté el valor mínimo
14:40de la función del error quiere decir que
14:42hemos encontrado
14:43y el mejor parámetro de nuestro modelo
14:46de regresión en este caso de nuestro
14:48modelo de regresión lineal que estamos
14:50utilizando simplemente como cualquier
14:53otro ejemplo bien pudimos haber
14:55utilizado el perceptor una red neuronal
14:58ok entonces qué más tenemos aquí dentro
15:02de nuestros datos
15:03tenemos dos parámetros en el modelo de
15:06regresión lineal tenemos la pendiente
15:08que está
15:09acostada está nuestra línea podría estar
15:13así así así ésta es una pendiente m en
15:17este punto y de hecho está pendiente es
15:21de
15:212.10 ya esto es un valor óptimo y otro
15:27parámetro que tenemos en un modelo de
15:28regresión lineal es esta línea en qué
15:31parte cruza el eje de las y en qué parte
15:36la cruza aquí yo estoy
15:38con toda la intención haciendo un modelo
15:42de regresión que tenga un cruce en el
15:46eje de las y exactamente en el cero y
15:50con eso yo solo me voy a enfocar en un
15:53solo parámetro en determinar qué tan
15:55acostada está la mi línea recta estoy
15:59enfocándome en la optimización del
16:01parámetro y me di la pendiente de la
16:05recta ok entonces ya está ya
16:08determinamos un modelo que tiene una vez
16:11de cero entonces es interceptó lo vamos
16:14a ignorar completamente y el valor
16:16óptimo está 2.1 ya lo sabemos lo vamos a
16:19utilizar simplemente como referencia de
16:21hecho vamos a llegar a ese valor
16:24utilizando el gradiente descendiente
16:26además conocemos la suma de cuadrados de
16:30los residuos es simplemente el error que
16:33tenemos para este modelo que es de 31
16:37puntos 42 esto ya lo calculamos nosotros
16:40por aquí recuerden es el valor conocido
16:44al área esta es nuestra variedad el
16:45objetivo menos lo que nuestro modelo nos
16:49está diciendo lo que nuestro modelo está
16:51prediciendo y eso lo elevamos al
16:53cuadrado es justo lo que tenemos aquí y
16:56lo sumamos absolutamente esto lo estamos
16:59haciendo muy fácil a raíz de que lo
17:02estamos realizando con un pay que nos
17:06permite hacer cálculos vectoriales si
17:08alguien está interesado en un país que
17:10de hecho debería aquí arriba les dejo
17:14una lista a una playlist que ya tenemos
17:16en este canal ok ahora ya sabemos cuál
17:21es el error de un modelo óptimo para
17:24estos tres datos que nosotros tenemos y
17:27ya tenemos la pendiente óptima que es de
17:312.10 ahora sí estamos listos para tratar
17:36de llegar justo a ese valor utilizando
17:39el mecanismo del algoritmo del gradiente
17:43de descendiente entonces recuerdan esto
17:46que les comentaba yo acá en la persona
17:49pisa hacia delante pisa hacia atrás
17:51pisas a la izquierda pisa a la derecha
17:54esto como nosotros lo podemos ver dentro
17:59de un modelo de aprendizaje de máquina
18:02eso lo podemos ver nosotros variando el
18:04parámetro que queremos nosotros
18:06optimizar en este caso recuerden lo
18:09simplificamos solo tenemos un parámetro
18:12la pendiente que tan acostada va a estar
18:15nuestra línea para eso yo ya que prepare
18:19una visualización de diferentes
18:22pendientes para los diferentes datos que
18:24nosotros tenemos es un rango de interés
18:28para que nosotros lo podamos ver
18:30claramente aquí yo ya estoy creando un
18:33rango de diferentes pendientes que van
18:35de 2.5 al
18:371.6 y simplemente vamos a graficar estas
18:41pendientes en este rango de 3 ok aquí
18:45tenemos exactamente los mismos datos que
18:48teníamos nuestros 3 puntos 2 y 3 y
18:52tenemos múltiples pendientes múltiples
18:56líneas con múltiples pendientes de aquí
18:58como todas se están pegando porque todas
19:02tienen el interceptó debe igual a 0
19:06cruzan el eje de las y en el ser por eso
19:10se van pegando y atrás se van abriendo
19:12ok pues aquí tenemos diferentes
19:15pendientes la pendiente azul de
19:182.5 es justo está 2.4 2.3 2.2
19:242.12 1.9 1.8 y 1.7 son diferentes
19:30expedientes obviamente cada una de estas
19:32pendientes nos está representando un
19:35diferente modelo de regresión lineal son
19:37los pasos que les comentaba hacia atrás
19:40y delante se les quiera hacer la derecha
19:41y cada uno de estos pasos cada una de
19:46estas pendientes tendrá asociado en sí
19:47un cierto error aquí yo ya me di a la
19:50tarea de calcular el error el error del
19:542.5 de la pendiente de 2.5 es
19:5737.31 con esto me refiero al error y
20:00ricky si esta suma de los residuos al
20:05cuadrado y podemos ver que para el
20:08modelo de pendiente de 2.4 es de 50 y
20:121.44 para el otro es de 40 33 31 33 41
20:1852 69 que está pasando aquí cada una de
20:22estas pendientes tiene un error
20:24diferente podemos ver cuáles son las que
20:27tienen los errores más grandes los
20:30errores más grandes es de la azul y de
20:33este verde la de arriba y la de abajo la
20:37azul tiene 67 y la de abajo tiene 69
20:42aquí nos interesa la magnitud de hecho
20:46ambas tienen errores muy similares
20:48porque la línea con la pendiente de
20:532.1 que es esta maravilla que está por
20:56aquí está justo en medio
20:59es por eso que conforme nos vamos
21:01acercando a la pendiente óptima el error
21:04va reduciendo pero conforme nos vamos
21:08alejando de la pendiente óptima el error
21:12va aumentando entonces estos son
21:15nuestros pasos ok aquí no opte yo por
21:20ninguna dirección simplemente dije bueno
21:23qué pasa ha sido en múltiples pasos en
21:24diferentes direcciones y aquí podemos
21:27ver si efectivamente podemos construir
21:30estos modelos y para cada uno de ellos
21:32podríamos tener ciertos errores y el
21:34error nos está dando cierta información
21:37que tanto nos estamos alejando claro
21:40aquí tenemos la gran ventaja de que
21:43sabemos cuál es el valor óptimo pero el
21:46gradiente descendiente funciona aún sin
21:49saber el valor óptimo entonces vamos
21:53viendo todavía un poquito más de detalle
21:56ya gráfica vamos los diferentes modelos
21:59vimos los errores pero vamos a graficar
22:03en estos errores para que nos quede
22:04todavía más claro qué es lo que está
22:07pasando para eso yo aquí tengo código de
22:10matt del dif y nos genera esta gráfica
22:13que tenemos aquí es el error el rs5 esta
22:17suma de los residuos al cuadrado y en el
22:21eje de las x tenemos la pendiente que ya
22:24sabemos que el óptimo está muy cerca de
22:292.1 cuando utilizamos una pendiente de
22:322.1 ahí es el error más bajo de nuestro
22:37modelo y podemos ver que los errores más
22:41altos efectivamente se dan cuando
22:44tenemos pendientes alejadas de este 2.1
22:47el 1.7 y el 2.5 entonces vean aquí justo
22:52tenemos la función de error graficada y
22:57la misma función de error nos está
23:00indicando visualmente dónde se encuentra
23:04el error mínimo
23:06para que el valor de la pendiente se
23:09encuentra un error mínimo en mi modelo
23:12de regresión lineal sin embargo cómo
23:14puedo hacer esto vía programación
23:19automáticamente para esto requerimos las
23:22derivadas pero en este punto pareciera
23:25un concepto extremadamente matemático
23:27pero sí lo es sin embargo tiene una
23:29interpretación bastante aterrizada una
23:32derivada no es otra cosa más que una
23:34razón de cambio que tanto cambia una
23:37variable y con respecto a otra que tanto
23:41va a cambiar mi error con respecto a la
23:45pendiente vamos a ver todavía un poquito
23:48más de detalle para aterrizar justo este
23:51concepto entonces para eso nosotros
23:54tenemos que preparar nuestra función de
23:58error y una vez que nosotros creamos la
24:01función de error entonces si le sacamos
24:03la derivada y con eso vamos a obtener la
24:06razón de cambio para el error en función
24:09de la pendiente ok vamos a programar
24:13primero la función de error una vez que
24:17tenemos programada la función de error
24:19ahora sí le vamos a poder sacar la
24:22derivada afortunadamente aquí es
24:24bastante sencillo calcular el error dado
24:27que estamos utilizando la función de
24:29error o de pérdida como se le conoce
24:31también dentro de este contexto de la
24:33suma de los cuadrados de los residuos
24:36que no es otra cosa más que el valor
24:39real menos el valor predicho por nuestro
24:42sistema elevado al cuadrado la suma de
24:45cada uno de esos residuos elevada al
24:48cuadrado
24:49entonces aquí sacamos ventaja de que
24:52tenemos los datos de tres personas esos
24:55siempre los tendríamos tenemos una
24:57persona que gana aproximadamente seis
24:59mil pesos con cinco años de experiencia
25:01una persona que gana aproximadamente 16
25:03mil pesos con seis años de experiencia y
25:05una persona que gana 26 mil pesos con 13
25:08años de experiencia esto ya lo conocemos
25:10estos son los datos que nos van a servir
25:13para qué a nuestro poder para ajustar
25:15los parámetros entonces cuál sería la
25:18función de error a partir de estos datos
25:21para eso yo voy a definir aquí
25:22simplemente error va a ser igual al
25:26valor que ya conozco que es
25:28efectivamente correcto para la persona 1
25:31que en este caso es de 6.85 techo
25:35permítanme lo voy a copiar 6.85 aquí
25:38está y ahora qué es lo que tengo que
25:41hacer para aproximar me a la creación de
25:44mi función de error que es la suma de
25:46los cuadrados de los residuos
25:47simplemente restarle lo que nuestro
25:50modelo
25:51calcularía y nuestro modelo lo calcular
25:54ya en función de la pendiente que es el
25:55parámetro que nosotros queremos ajustar
25:57en por el número de años de experiencia
26:00pero eso ya lo tenemos nosotros aquí
26:02para la primera persona es simplemente 5
26:08y quedamos que lo elevamos al cuadrado
26:11para quitar los signos y para darle
26:13mayor relevancia a los errores más
26:15grandes y menor relevancia de los
26:17errores más pequeñas entonces lo
26:19elevamos al cuadrado pero este es el
26:22error de la primera persona entonces qué
26:26tenemos que hacer sumarle el error de la
26:29segunda persona y para eso pues nosotros
26:33ya conocemos exactamente el dato
26:37correcto
26:3816.83
26:40menos lo que calculó un modelo de m
26:46por los años de experiencia de esa
26:49persona que ya los conocemos 6 y
26:52aplicamos justo lo mismo lo elevamos al
26:55cuadrado y repetimos exactamente lo
26:58mismo para la tercer persona entonces
27:01puede copiar esta línea aquí está
27:06y le voy a restar el cálculo del modelo
27:09para una pendiente y mirada y le vamos a
27:12decir que es de 13 años de experiencia e
27:16igual lo elevamos al cuadrado ahora ya
27:19tenemos así de simple nuestra función de
27:22error claro ahora corresponde derivar la
27:27para poder obtener esta razón de cambio
27:29para que cuando yo le ponga un valor de
27:33m nos diga hacia donde tenemos que
27:36caminar y para eso voy a hacer uso de
27:40zinc para que es python simbólico
27:44entonces tengo que definir un símbolo
27:46que símbolo voy a definir una m
27:50ok entonces pongo mi m la defino justo
27:54utilizando python simbólico que ya lo
27:57importamos con el apodo de zinc justo en
28:00la parte inicial del vídeo ponemos el
28:03símbolo que nosotros queremos
28:05generar y en este caso le estamos
28:08diciendo vamos a tener una variable m y
28:10es un símbolo sobre esta variable
28:13nosotros vamos a hacer una operación
28:15simbólica qué operación vamos a hacer la
28:17derivada ok ahora si ya definimos
28:22nuestro símbolo tenemos nuestra función
28:24ya sólo corresponde sacar la derivada
28:27claro esto está bastante sencillo lo
28:29podríamos hacer manualmente pero estamos
28:31en un canal de programación entonces
28:33vamos viendo cómo derivar simbólicamente
28:36esta función ya definimos nuestro
28:39símbolo es muy sencillo la derivada de
28:41la función del error nosotros la podemos
28:43calcular fácilmente utilizando sin punto
28:46pib y pasándole la función que queremos
28:50derivar que en este caso es la del error
28:53y con respecto a que cuál va a ser la
28:56variable que nosotros vamos a derivar en
28:58este caso sólo tenemos una variable que
29:00es la pendiente y así está con eso
29:05calculamos nosotros justo la derivada de
29:08la función del error es bastante
29:10sencillo
29:12aquí les recomiendo si alguien no tiene
29:14conocimientos de cómo derivar le
29:16recomiendo que chequen un libro de
29:18cálculo es algo muy muy importante para
29:20avanzar en sus conocimientos de
29:22aprendizaje de máquinas conocimientos de
29:25cálculo son muy importantes para poder
29:27profundizar no obstante aquí lo
29:30importante es que conozcamos la
29:32interpretación de la derivada ok ya
29:36tenemos la derivada vamos a jugar un
29:38poquito con ella vamos a evaluar esta
29:41derivada para diferentes pendientes y
29:43así nosotros podemos ver si
29:45efectivamente nos está dando cierta
29:47información para determinar hacia donde
29:49debemos de caminar e inclusive la
29:51magnitud de qué tanto podemos caminar en
29:53esa dirección ok ahora sí vamos a
29:56evaluar para las diferentes pendientes
29:57recordando que vemos un vector de
29:59pendientes arriba que inclusive grafica
30:00mos entonces para cada una de esas
30:02pendientes que tenemos aquí
30:04vamos a imprimir la derivada que
30:07nosotros acabamos justo de programar y
30:11la vamos a evaluar vamos a ponerle aquí
30:13evaluación de chavannes vamos a poner la
30:16formateada con dos decimales aquí está y
30:19ahora simplemente evaluamos la derivada
30:22para evaluar una función en simple
30:26simplemente hacemos uso del método y fal
30:29efe entonces ponemos derivada punto
30:32igual
30:33efe y le decimos que sustituya el valor
30:37de m por cada una de las pendientes que
30:39nosotros tenemos en nuestro vector
30:42entonces escribimos subs
30:46aquí está escribimos la m y le decimos
30:49que cada una de estas m va a ser
30:52sustituida por cada una de las
30:54pendientes que nosotros tenemos y ahora
30:57sí vamos a ejecutar nuestro código y
31:00veamos que el resultado nos está dando
31:03vean bueno de entrada esta es la
31:05derivada de la función del error
31:07obviamente lo podemos hacer manualmente
31:10pero aquí lo hicimos bien programación
31:12porque estamos en un canal de
31:14programación y aquí tenemos los
31:17diferentes valores
31:19de la derivada evaluada en esta m noten
31:24todos los de arriba son positivos todos
31:28los de abajo son negativos
31:31el valor más pequeño está entre este y
31:36este el valor más pequeño ahí es justo
31:42este que nosotros tenemos por aquí es
31:44cuando la pendiente se acerca justo a
31:47este valor ok pues aquí ya tenemos
31:51efectivamente un error la derivada del
31:54error lo estamos evaluando para un valor
31:57de una pendiente dada y algún tipo de
32:01información nos está dando con esto de
32:03que es positivo y negativo ahora vamos a
32:06graficar esta información para ver cómo
32:09se ve ok aquí tengo yo ya preparado
32:14código para graficar estas evaluaciones
32:16de la derivada del error y aquí estoy
32:23presentando exactamente casi la misma
32:26información que teníamos tenemos aquí el
32:28error que está denotado por estos puntos
32:31cada uno de ellos en diferentes colores
32:33y en la parte del eje de las x tenemos
32:37las pendientes ahora estas líneas
32:42qué es lo que nos está representando
32:44aquí nosotros estamos
32:48graficando el gradiente nosotros estamos
32:52graficando la evaluación de la derivada
32:57del error evaluada en una pendiente dada
33:00por ejemplo aquí en el 1.7 nosotros
33:05tenemos nuestra función del error y la
33:08derivamos esta derivada le hablamos en
33:121.7 y después la gráfica moss es esta
33:17línea es una tangente a nuestra función
33:20de error la podemos ver aquí claramente
33:21como ésta no por usar la función es
33:24tangente aunque ahora tenemos la
33:28derivada del error evaluada en 1.8 y
33:31aquí tenemos otra tangente y acá tenemos
33:35la derivada del error y evaluada en 1.9
33:38y note tiene otra vez está tan gente que
33:42está por ahí y que pasa tocando
33:44exactamente en este punto a la función
33:48de error la toca es una tangente que
33:51está por ahí y lo mismo podemos ver aquí
33:53y lo mismo podemos hacer aquí no tener
33:55esta que está aquí tenemos nuestra
33:57función de error que evaluamos la
33:58derivada de la función de error justo en
34:00ese punto y vean lo que nos genera una
34:04línea tangente pero no tiene aquí la
34:07pendiente de esta línea tangente se está
34:10aproximando a cero eso que nos está
34:13diciendo recuerdan nuestro contexto
34:15extraño del inicio que nosotros estamos
34:17muy cerca del fondo que si damos un paso
34:20hacia adelante un paso hacia atrás paso
34:22a la izquierda un paso hacia la derecha
34:23nosotros nos damos cuenta que el declive
34:26de cada uno de esos pasos que tanto
34:28bajamos por cada uno de ellos es muy
34:30poco entonces aquí estamos viendo para
34:34qué nos sirve la derivada si nosotros
34:38aumentamos una pelotita acá o una
34:40pelotita para acá y esta pelotita caería
34:43obviamente al fondo si nosotros
34:45lamentamos aquí noten la pendiente va a
34:49provocar que esa pelotita caiga más
34:51rápido si nosotros lamentamos aquí la
34:53pendiente
34:55o jarque esa pelotita no caerá tan
34:57rápido entonces estás pendientes de la
35:01derivada del error nos están diciendo la
35:03dirección de hacia dónde se va a ir la
35:06pelotita si la soltamos aquí
35:07automáticamente sabemos que es hacia la
35:09izquierda si la soltamos aquí
35:10automáticamente sabemos que es hacia la
35:12derecha si la soltamos aquí pues bueno
35:16está pendiente va a provocar que baje
35:18muy rápido la pelotita sí lamentamos
35:20aquí va a provocar que baje muy rápido
35:22la pelotita caso contrario si lamentamos
35:25por aquí va a provocar que baje sí pero
35:28muy lento entonces con esto nosotros
35:31estamos calculando el gradiente que
35:34tanto cambia nuestra función de error en
35:37función de una pendiente dada además nos
35:41está diciendo hacia dónde tenemos que
35:43caminar la dirección pero también nos
35:45está dando la magnitud esto es
35:47verdaderamente una maravilla ahora vamos
35:51a generalizar lo porque lo que tenemos
35:54aquí es exclusivamente
35:57un parámetro pero pues los modelos de
36:00aprendizaje de máquinas las técnicas de
36:02aprendizaje de máquinas tienen muchos
36:04parámetros en este caso inclusive
36:06estamos con una regresión lineal la
36:08revisión lineal pues tiene dos
36:10parámetros el interceptó la ve donde
36:12cruza la línea con el eje de las y
36:14griegas y si también la pendiente y para
36:19fines de explicación nosotros asumimos
36:21que todas las líneas cruzaban en cero y
36:25eso nos permitió ignorar la ve pero qué
36:28pasa si no la ignoramos si queremos
36:31optimizar también y sabe es intercepta
36:34son dos parámetros a considerar entonces
36:37necesitamos hacer una generalización
36:40sin embargo esta generalización es
36:42bastante sencilla porque porque
36:45simplemente repetimos el mismo proceso
36:49pero cuando unos pequeños cambios ahora
36:52vamos a suponer que tenemos igual un
36:55modelo de regresión lineal pero ahora
36:58este modelo de regresión lineal lo vamos
37:00a querer optimizar tomando en cuenta
37:03parámetros 1 es la m la pendiente y el
37:07otro es la vez el interceptó donde la
37:11línea cruza el eje de las y
37:15ahora si recordamos en el ejemplo
37:17anterior sólo teníamos la m yo me
37:21encargué de que la b fuera igual a 0
37:25para poder explicar de una forma más
37:27sencilla sin embargo comúnmente las
37:31técnicas de aprendizaje de máquina
37:34tienen dos o más parámetros a optimizar
37:37entonces en este caso vamos a repetir
37:39exactamente un proceso pero tomando en
37:41cuenta los dos parámetros para eso yo
37:44aquí tengo datos muy similares a los que
37:47teníamos anteriormente sin embargo yo
37:50los varíe un poco para que tuviéramos un
37:52interceptó diferente de cero y una
37:56pendiente diferente de cero ahora
37:59permítanme ejecutar este código para
38:01visualizar el modelo y los datos
38:05aquí lo podemos ver igual tenemos en
38:09color amarillo los datos reales en color
38:12azul los datos pre dichos y en rosa
38:15tenemos nuestro modelo y ahora qué es lo
38:19importante aquí tenemos el valor del
38:22interceptó donde el modelo donde la
38:24línea cruza el eje de las y y es igual a
38:29menos
38:314.38 y la pendiente en este caso es de
38:352.45 e igual tenemos un error un error
38:39de la suma de los cuadrados de los
38:42residuos de
38:444.03 y obviamente nosotros queremos que
38:48al momento de que optimicemos nuestro
38:52modelo a través de el algoritmo del
38:55gradiente descendiente pues nos dé estos
38:58valores
39:00245 para la pendiente y menos 4.38 para
39:04el interceptó
39:07repetimos nuevamente el mismo
39:10procedimiento tenemos que calcular el
39:13error en el otro nosotros hicimos la
39:16fórmula del error
39:18exclusivamente en función de la m y este
39:23término que está aquí el más b de cada
39:26uno de ellos no estaba porque porque era
39:29igual a cero yo así lo definí
39:31explícitamente
39:33ahora tenemos dos parámetros por tanto
39:36la predicción involucra tanto la m la
39:40pendiente como el interceptó y por tal
39:42razón tenemos que definir así nuestra
39:45función de error ahora tenemos dos
39:48variables que pasa cuando gráfica mos la
39:51función de error en el otro se veía una
39:54función con pixar en este caso como se
39:59verá igual convexa pero de una forma
40:03tridimensional
40:05ahora que es lo que tenemos aquí cada
40:08uno de estos puntos y en moralito
40:11la evaluación de la función de error
40:14para una pendiente dada y para un
40:17interceptor aad aquí podemos ver un
40:20punto del error que tendría ese modelo
40:24para una pendiente igual a cero y para
40:26un interceptó de menos 10 eso es justo
40:30lo que tenemos aquí graficando cuál es
40:33el error para esos valores de los
40:37parámetros y igual como hicimos en el
40:40ejemplo anterior yo aquí estoy
40:42graficando el rango de interés donde yo
40:46ya sé dónde se encuentra el valor óptimo
40:49claro esto lo estoy haciendo
40:51exclusivamente por razones
40:54didácticas para que sepamos qué es lo
40:57que estamos haciendo hacia dónde vamos
40:59sin embargo esto no es un requisito del
41:03algoritmo del gradiente descendiente y
41:06lo que estoy graficando aquí en color
41:08azul claro es justo donde se encuentra
41:11el valor óptimo que fue igual calculado
41:14con la librería de sakhir line
41:17utilizando el método
41:19cuadrados que es el método que ya viene
41:21por defecto para crear los modelos de
41:24regresión lineal ok entonces así lo
41:28podemos ver nosotros tridimensionalmente
41:30para cuando tenemos dos parámetros vamos
41:34avanzando en el procedimiento recuerdan
41:37una vez que nosotros definimos una
41:39función de error que fue lo que hicimos
41:41sacamos la derivada de esa función de
41:44error y para que sacamos la derivada de
41:46la función del error para poder calcular
41:48el gradiente y que ahora nos diga hacia
41:52donde tenemos que avanzar porque justo
41:55cuando esa derivada de la función del
41:57error es igual a cero y es cuando hemos
42:02encontrado en nosotros ese valor mínimo
42:05y recuerdan en el caso anterior nos
42:07decía igual la magnitud y la dirección
42:10de hacia dónde avanzar acá es
42:14exactamente lo mismo la única diferencia
42:16que nosotros tenemos aquí es que ahora
42:18involucramos dos variables y por tanto
42:21definimos dos símbolos utilizando la
42:23librería
42:24sin pay para cálculo simbólico dentro de
42:28payton y poder calcular de una forma muy
42:30sencilla las derivadas en este caso y
42:33este es un concepto de cálculo no
42:36podemos sacar la derivada explícitamente
42:38porque la derivada sólo se puede hacer
42:40cuando tenemos una sola variable aquí
42:44tenemos dos variables
42:47entonces qué es lo que tenemos que hacer
42:49la derivada parcial recuerden la
42:53derivada es simplemente una razón de
42:56cambio cómo se comporta la función del
42:59error cómo se comporta el error cuando
43:01yo alteró la pendiente cuando yo alteró
43:04el interceptó cómo se comportaría el
43:07error para eso nosotros igual sacamos la
43:10derivada pero la derivada a pasear esto
43:13va a implicar que cuando yo derive por
43:16ejemplo con respecto a la pendiente se
43:20toma como constante el interceptó y
43:23cuando yo derive con respecto al
43:26interceptó se toma como constante la
43:28pendiente y así tengo yo una derivada
43:31del error con respecto al interceptó y
43:35tengo yo una derivada del error con
43:37respecto a la pendiente estas son
43:40derivadas parciales porque estamos
43:44involucrando dos variables aquí como es
43:47exactamente el mismo código yo ya lo
43:49dejé preparado y lo vamos a ejecutar y
43:54podemos ver que la derivada del error la
43:58derivada parcial con respecto a m de la
44:01función del error involucra
44:03efectivamente tanto b como m y tenemos
44:07exactamente lo mismo para la derivada
44:10parcial de la función de error con
44:12respecto a b cada una de estas derivadas
44:16nos da el gradiente pero en función de
44:19uno de los parámetros de nuestro modelo
44:21en uno es la pendiente y en otro es
44:24justamente el interceptó es exactamente
44:27la misma interpretación que teníamos en
44:30el ejemplo más
44:32nada más que aquí tenemos la derivada
44:35parcial porque involucramos dos
44:37variables ok entonces ya tenemos esta
44:41derivada parcial ahora sí estamos listos
44:44para ver el pseudo código del gradiente
44:47descendiente tenemos toda la parte
44:50matemática
44:51resuelta cómo funciona este algoritmo y
44:55hasta cierto punto lo definimos en la
44:58parte inicial de este vídeo sin embargo
45:00vamos definiendo lo un poquito más
45:02formal cuando llegaba el paracaidista y
45:07caía en esa zona montañosa yo les hable
45:10de que daba ciertos pasos pero cuántos
45:13pasos va a dar a lo mejor alguien podría
45:16decir pues ya no más doy diez pasos otra
45:18persona podría decir yo doy veinte pasos
45:20cuantos pasos requerimos nosotros para
45:22llegar al arroyo para llegar al mínimo
45:25para optimizar nuestro modelo pues en
45:30muchos casos no lo sabemos por lo tanto
45:32se define una constante la cual
45:34normalmente se ajusta de forma
45:36experimental
45:38en función de los mínimos que vamos
45:40detectando en este caso simplemente
45:43definimos un máximo de pasos un máximo
45:46de interacciones de este algoritmo en
45:49este caso de 10.000 podría ser un buen
45:52valor y obviamente vamos a necesitar una
45:55variable que nos va a ir contando
45:57cuántos pasos ha dado nuestro
45:59paracaidista y para eso tenemos esta
46:02variable llamada integración ahora
46:05tenemos esta tasa de aprendizaje que
46:10será esto qué significado tiene con
46:14respecto a este ejemplo ficticio que
46:16planteamos inicialmente ok con
46:18integraciones máximas sabemos cuántos
46:21pasos dar pero de qué tamaño va a ser
46:23cada paso va a ser un paso t va a ser un
46:26pasito va a ser un paso normal eso es
46:29justo lo que nos está definiendo la tasa
46:31de aprendizaje qué tamaño va a tener ese
46:35paso obviamente nosotros podríamos decir
46:37no yo quiero aprender
46:39muy rápido de hecho lo podríamos hacer
46:42así
46:43sin embargo recuerden nosotros vamos
46:45dando pasitos pasitos pasitos pasitos
46:47pasitos pasitos hasta que llegamos al
46:50óptimo al mínimo sin embargo imagínense
46:53que arrancamos aquí arriba y decimos no
46:56yo no voy a dar así llevo a dar brincos
46:58pues qué pasa de aquí yo puedo brincar
47:00pareja un paso tote que pasó me brinqué
47:04de brinque el mínimo y digo bueno pues
47:08regreso pues vuelvo a brincar regreso
47:10brincar aplicar brincar brincar y así
47:13voy y cada vez que voy brincando me voy
47:16brincando el mínimo de mi función de
47:18error eso no lo quieres a raíz de eso se
47:21define una tasa de aprendizaje
47:23relativamente pequeña igual que en el
47:26caso de las iteraciones máximas la tasa
47:28de aprendizaje es un valor que se ajusta
47:31en función de experimentación en este
47:34caso nosotros vamos a utilizar
47:35simplemente
47:360.001 yo ya hice algunas pruebas y estos
47:39parámetros realmente nos dan buenos
47:41resultados
47:43en nuestro ejemplo anterior teníamos un
47:45paracaidista que pudo haber caído en la
47:48montaña de la izquierda en la montaña de
47:50la derecha un poquito más para acá un
47:51poquito más para allá igual aquí donde
47:54vamos a arrancar explorar pues podríamos
47:57arrancar aquí con un valor de una
47:59pendiente y de un interceptor o
48:02podríamos arrancar con otros valores
48:04completamente diferentes o un poquito
48:06para
48:07independientemente de los valores que
48:09nosotros seleccionemos este algoritmo
48:11nos va a llevar al mínimo al menos para
48:15el caso de los modelos de regresión
48:17lineal para los cuales se conoce que
48:19tienen un solo mínimo global a raíz de
48:22que su función de error es convexa que
48:23tiene esta esta forma por eso es que
48:26forzosamente vamos a llegar al mínimo si
48:31ponemos una tasa de aprendizaje
48:32relativamente pequeña y una cierta
48:34cantidad de instalaciones máximas ok
48:37entonces qué es lo que queda aquí pues
48:41simplemente empezar a dar pasitos
48:42entonces recuerdan del paso pero hacia
48:46donde lo doy en qué magnitud
48:48pues para eso necesito calcular los
48:50gradientes en función de la posición
48:52donde estoy pero eso ya sabemos cómo
48:55hacerlo de hecho ya calculamos nosotros
48:57las derivadas parciales tanto de la
49:00función de error con respecto al
49:01interceptó como de la función del error
49:03con respecto a la pendiente nosotros ya
49:06calculamos los gradientes las razones de
49:10cambio y en función del gradiente
49:12nosotros vamos a actualizar nuestros
49:16parámetros la nueva pendiente y el nuevo
49:19interceptó aumentamos una integración
49:21más verificamos si todavía no llegamos
49:24al máximo de interacciones que nosotros
49:26definimos si no es así otra vez dimos un
49:29paso calculamos el gradiente
49:30determinamos hacia donde caminar y con
49:34qué magnitud y otra vez volvemos a
49:36actualizar nuestros parámetros la
49:38pendiente y el intercepta aumentamos el
49:41número de estaciones y lo repetimos así
49:43hasta que eventualmente llegamos al
49:46número de iteraciones máximas y si
49:49seleccionamos apropiadamente una buena
49:51tasa de aprendizaje y un cierto número
49:53de intenciones máximas habremos llegado
49:56a nuestro mínimo al menos para el caso
49:59de los modelos de regresión lineal ok
50:03este es el algoritmo básico ahora vamos
50:05simplemente a programarlo para eso yo ya
50:09tengo aquí un poco de código preparado
50:12igual el número máximo de instalaciones
50:15está en 10.000 justo lo que teníamos en
50:17nuestro pseudo código definir la tasa de
50:20aprendizaje igual a
50:210.00 uno tiene que ser relativamente
50:25pequeña y ese es un valor relativamente
50:28común que nosotros utilizamos cuando
50:31estamos trabajando con este tipo de
50:32algoritmos y
50:34como valor es completamente arbitrario
50:37aleatorios use una pendiente de 0 y un
50:40interceptó de menos 10 lo estoy poniendo
50:42exclusivamente en ese valor porque al
50:45momento de graficar no se ve muy claro
50:48que es lo que está pasando sin embargo
50:50crea me pude haber puesto cualquier
50:53valor y si no me creen los invito por
50:56favor descarguen esta libreta de júpiter
50:59de nuestro sitio de hip hop y jueguen un
51:02poquito con el código y vean cómo se
51:04comporta este algoritmo y lo que tenemos
51:07aquí es un arreglo en un país que nos va
51:12a permitir capturar los diferentes
51:15errores conforme vamos ajustando
51:18los parámetros de la pendiente y el
51:21interceptó la única razón por la que
51:24estoy incluyendo aquí este vector es
51:26porque quiero graficar cada uno de los
51:29pasitos para que veamos
51:31claramente qué pasó porque efectivamente
51:34si llegamos a los valores óptimos de la
51:37pendiente el interceptó y quedamos que
51:41teníamos ahí un simple ciclo en este
51:43caso yo voy a utilizar un force funciona
51:46exactamente igual al pseudo código del
51:47wine que teníamos aquí arriba entonces
51:49no pasa nada y vamos a calcular primero
51:53los gradientes en función de las
51:54derivadas parciales de la pendiente y
51:57del interceptó que ya nosotros definimos
52:00y estos gradientes los voy a almacenar
52:03en una simple lista que tenga dos
52:07elementos el gradiente de la pendiente y
52:10el gradiente del interceptó entonces eso
52:13ya quedamos lo calculamos nosotros con
52:16la derivada del error la derivada
52:19parcial del error con respecto a la
52:22pendiente la evaluamos que ya sabemos
52:24que le va hablamos con punto vale efe y
52:27sustituimos el valor de m con el valor
52:32de la pendiente arbitrario que nosotros
52:34definimos al menos para la primera
52:36integración
52:38aquí nuestras derivadas parciales
52:41recuerdan tienen dos variables una es la
52:45pendiente y la otra es el interceptor
52:47entonces metemos el interceptó e igual
52:50tenemos que evaluarlo con el valor
52:55arbitrario que nosotros definimos en
52:57este caso menos 10 interceptó
53:00ahí está aquí es una comida y permítame
53:05pueda ajustar
53:07el código ok ahora sí ahí estamos
53:12aquí está ahora aquí tenemos el
53:14gradiente con respecto a la pendiente
53:16pero nos queda con respecto al
53:21interceptó en este caso quedamos que le
53:24vamos a almacenar en una lista entonces
53:28yo defino ahí mi lista y ahora utilizo
53:32la derivada del error la derivada
53:34parcial de el error con respecto al
53:37interceptó lo evalúo con el valor
53:41completamente arbitrario que yo definí
53:44aquí está
53:48pongo la pendiente de ahí pongo el valor
53:52de interceptó esta y ahora si cierro mi
53:58lista del gradiente aquí está ya tengo
54:02los gradientes en estos ambientes me van
54:05a decir en qué dirección y con qué
54:07magnitud debo yo de avanzar ahora qué es
54:12lo que queda actualizar los valores de
54:15mis parámetros poco a poco poco a poco
54:18paso a paso mis parámetros son
54:21simplemente la pendiente
54:24la cual se actualiza con el valor que
54:28tiene hasta ese punto pero en función
54:31del gradiente que justo nosotros
54:33acabamos de calcular y quedamos que
54:35debemos determinar qué tan grande o qué
54:38tan pequeño debemos dar ese paso y eso
54:41nosotros lo hacemos a través de la tasa
54:44de aprendizaje entonces agarramos la
54:48tasa de aprendizaje
54:49luego multiplicamos
54:52el gradiente correspondiente que en este
54:54caso es el que se encuentra en la
54:56posición ser el gradiente
54:58correspondiente a la pendiente y aquí
55:02está lo podemos hacer y con eso ya
55:04actualizamos el valor de la pendiente de
55:07hecho lo vamos a poner aquí abajito aquí
55:09está y tengo un error de dedo aquí
55:11pendiente listo ejecutamos y ahora si
55:15interceptó está repetimos exactamente la
55:21misma fórmula es el valor anterior
55:26- la tasa de aprendizaje por el
55:30gradiente correspondiente que se
55:31encuentra en la posición 1 que es justo
55:35este el correspondiente al interceptó
55:39ahora sí ya tenemos nuevos valores para
55:43la pendiente y para el interfecto aquí
55:46yo ya calculé cómo se afectaron mis
55:49parámetros una vez que di un paso ya sea
55:52la derecha a la izquierda hacia adelante
55:53o hacia atrás ahora sé dónde estoy
55:56parado y como ya sé dónde estoy parado
55:59que queda simplemente repetir volver a
56:03calcular los gradientes y actualizar
56:07repetir volver a calcular los gradientes
56:09y actualizar los parámetros ahora
56:14esto ya es el algoritmo del gradiente
56:17descendiente es relativamente sencillo
56:20una vez que sabemos qué es lo que
56:22estamos haciendo
56:23lo siguiente que voy a hacer es
56:25simplemente almacenar el error que voy
56:29obteniendo cada vez que doy un solo paso
56:33entonces para eso voy a utilizar el
56:35arreglo de nun para que justo definida
56:37ahí arriba
56:38se llama errores y lo vamos a almacenar
56:42para el paso y obviamente necesitamos
56:45guardar el valor de la pendiente y del
56:49interceptó para poderlo asociar al error
56:51de ambos
56:53entonces guardamos aquí la pendiente y
56:58ahora
56:59guardamos
57:02el interceptó
57:05y posteriormente aquí es uno y
57:08posteriormente
57:09lo que hacemos es agarrar la función del
57:14error que está definida aquí arriba y
57:17que ya quedamos que es la suma de los
57:19residuos al cuadrado
57:22pues con esta función simplemente le
57:25paso la pendiente y le pasó el
57:27interceptó y ahora sí ya voy a tener yo
57:31el error correspondiente en ese paso y
57:36cada vez que hago una instalación voy a
57:38guardar el error y cada vez que haga una
57:41iteración voy a guardar el error y así
57:42sucesivamente hasta que haya terminado
57:45con el número de generaciones y ya con
57:50eso terminamos permítanme ejecutar este
57:53código y para eso yo aquí tengo código
57:56complementario aquí está que simplemente
57:59nos va a imprimir los valores finales de
58:03los gradientes tanto para la pendiente
58:05como para el interceptó y nos va a
58:08imprimir el valor de la pendiente y el
58:10valor del interceptó este ya es el
58:13calculado con el método del gradiente
58:16descendiente y para que podamos tener
58:20una referencia de qué tan bueno o qué
58:22tan malo fue nuestro algoritmo yo aquí
58:25tengo los valores de la pendiente y del
58:28interceptó que fueron calculados con el
58:31método de mínimos cuadrados que viene
58:33implementado dentro de esa killer
58:35entonces ya tenemos una muy buena
58:37referencia de qué valores efectivamente
58:39debería de dar ahora antes de ejecutar
58:42permítanme revisar rápidamente el código
58:45para ver si no tengo un error si aquí
58:48tenemos un arbolito
58:49tenemos que regarla ine
58:54parece que todo ya está perfecto
58:56entonces si ejecutamos y no tiene aquí
59:00está tardando un poquito es porque está
59:03dando cada uno de los pasos que nosotros
59:06le dijimos que diera en este caso
59:09nosotros le dijimos que diera 10.000
59:12pasos y está actualizando nuestros
59:16valores para la pendiente y para el
59:18interceptó ok ya terminó aquí tenemos
59:22los resultados vean primero los valores
59:26de los gradientes cero y menos
59:300.002 para el caso del interceptó noten
59:35están muy
59:36cercanos a cero qué implica eso que las
59:41pendientes están prácticamente planas y
59:44qué pasa cuando están prácticamente
59:46planas y estamos cerca o en el mínimo de
59:52nuestra función de error eso lo podemos
59:55ver aquí muy claramente con ésta
1:00:00está pendiente aquí es muy cercana a 0 y
1:00:04lo mismo nos va a aplicar para cuando
1:00:08tenemos la forma tridimensional
1:00:11involucrando los dos parámetros de hecho
1:00:15aquí podría ser un poco extraño como lo
1:00:18estamos nosotros viendo a lo mejor
1:00:21alguien dice hoy en saná es el verdadero
1:00:22mínimo pues
1:00:24bien lo vemos así ahora sí aquí está se
1:00:28ve claramente cómo es este mínimo y aquí
1:00:31tendríamos nosotros las pendientes y
1:00:34estas pendientes estarían prácticamente
1:00:37ajustadas y eso es la representación del
1:00:42gradiente tendríamos el gradiente del
1:00:45interceptó y el gradiente
1:00:47correspondiente a la pendiente
1:00:48prácticamente
1:00:50acostados lo que nos indica que estamos
1:00:53en un mínimo de la función del error y
1:00:57por tanto hemos encontrado un valor
1:00:59óptimo para los parámetros de nuestro
1:01:03modelo
1:01:04ahora vamos a ver qué valores nos dio
1:01:07para la pendiente y qué valores nos dio
1:01:09para el interceptor primero de hecho
1:01:11veamos en la pendiente nos dio
1:01:142.44 vean 2.44 obviamente hay algunas
1:01:20variaciones con respecto a los decimales
1:01:23es perfectamente normal estamos dando
1:01:25pequeños pasos estamos ajustando poco a
1:01:28poco a partir de una posición que fue
1:01:31definida aleatoriamente o
1:01:33arbitrariamente en este caso ahora
1:01:36veamos el valor del interceptó menos
1:01:394.37 que es muy similar a menos
1:01:434.38 que es el valor que fue calculado
1:01:46con el método de mínimos cuadrados y con
1:01:50eso ya estamos nosotros
1:01:52optimizando nuestro modelo de regresión
1:01:55lineal
1:01:57ahora un último detalle para aumentar el
1:02:00entendimiento de esta técnica
1:02:04vamos graficando los errores estos
1:02:06errores que nosotros almacenamos aquí
1:02:09entonces yo ya aquí tengo el código
1:02:12preparado para graficar justo ese error
1:02:15simplemente lo vamos a ejecutar y vean
1:02:20arrancamos nosotros por acá pero
1:02:23nosotros arrancamos aquí y dimos un
1:02:25primer paso recuerdan cuando les dije
1:02:28que hay un ambiente además de darnos la
1:02:32dirección hacia donde tenemos que
1:02:34avanzar también nos daban la magnitud de
1:02:36aquí que fue nuestro valor inicial de 0
1:02:39y menos 10 recuerda pues dimos un brinco
1:02:42tote hasta donde hasta acá y como aquí
1:02:45ya nos empezamos a acercar al valor
1:02:49mínimo ya empezamos a dar pasos más
1:02:52pequeños y obviamente aquí estamos más
1:02:54cerca empezamos a dar pasos más pequeños
1:02:57más pequeños más pequeños más pequeños
1:02:59más pequeños hasta que eventualmente
1:03:02llega al mínimo de la función del error
1:03:06donde el valor de la pendiente y del
1:03:09interceptó podrían ser óptimos ok aquí
1:03:14debo mencionar estamos nosotros
1:03:17optimizando a partir de una función de
1:03:19error que es convexa que es el caso de
1:03:22los modelos de regresión lineal sin
1:03:25embargo no siempre es el caso y tenemos
1:03:29nosotros mínimos locales
1:03:32mínimos globales sin embargo ese es tema
1:03:35de otro vídeo si encontrara un valor en
1:03:39este video por favor denle un like y si
1:03:42aún no se han suscrito por favor
1:03:43consideren hacerlo mi nombre es también
1:03:46tierra hasta el próximo vídeo
1:03:50para papá para
1:03:51[Música]

About this transcript

This page contains the full transcript of Gradiente Descendente Paso a Paso con Python: Un Algoritmo de Optimización para Machine Learning by Codigo Maquina, generated from the public captions YouTube serves with the video. The transcript has 8,454 words across 1,324 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.