diff --git a/.gitattributes b/.gitattributes index bc8eb373e2940e630da5ebb2e095663e8f2832dd..006711cd0ac7a7eea24bc7dad62431c52a04b5f3 100644 --- a/.gitattributes +++ b/.gitattributes @@ -575,3 +575,11 @@ a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:s a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/02-Vectores/03-Modelo[[:space:]]RGB[[:space:]]y[[:space:]]su[[:space:]]implementación[[:space:]]en[[:space:]]Python.mp4 filter=lfs diff=lfs merge=lfs -text a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/02-Vectores/04-Adición[[:space:]]de[[:space:]]Vectores[[:space:]]Conceptos[[:space:]]y[[:space:]]Propiedades[[:space:]]Básicas.mp4 filter=lfs diff=lfs merge=lfs -text a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/02-Vectores/05-Suma[[:space:]]de[[:space:]]Vectores[[:space:]]en[[:space:]]Python[[:space:]]con[[:space:]]NumPy.mp4 filter=lfs diff=lfs merge=lfs -text +a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/02-Vectores/06-Producto[[:space:]]EscalarVectores[[:space:]]Conceptos[[:space:]]y[[:space:]]Propiedades[[:space:]]Básicas.mp4 filter=lfs diff=lfs merge=lfs -text +a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/02-Vectores/07-Operaciones[[:space:]]con[[:space:]]Escalares[[:space:]]y[[:space:]]Vectores[[:space:]]en[[:space:]]Python[[:space:]]usando[[:space:]]NumPy.mp4 filter=lfs diff=lfs merge=lfs -text +a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/02-Vectores/08-Producto[[:space:]]Interno[[:space:]]de[[:space:]]Vectores[[:space:]]Definición[[:space:]]y[[:space:]]Propiedades.mp4 filter=lfs diff=lfs merge=lfs -text +a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/02-Vectores/09-Producto[[:space:]]Interno[[:space:]]de[[:space:]]Vectores[[:space:]]en[[:space:]]Python[[:space:]]con[[:space:]]NumPy.mp4 filter=lfs diff=lfs merge=lfs -text +a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/02-Vectores/10-Análisis[[:space:]]de[[:space:]]Sentimientos[[:space:]]de[[:space:]]Tweets[[:space:]]con[[:space:]]Vectores[[:space:]]de[[:space:]]Palabras.mp4 filter=lfs diff=lfs merge=lfs -text +a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/03-Funciones[[:space:]]lineales/01-Funciones[[:space:]]Lineales[[:space:]]Transformación[[:space:]]de[[:space:]]Vectores[[:space:]]en[[:space:]]Escalares.mp4 filter=lfs diff=lfs merge=lfs -text +a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/03-Funciones[[:space:]]lineales/02-Funciones[[:space:]]Lineales[[:space:]]y[[:space:]]Propiedades[[:space:]]de[[:space:]]Superposición.mp4 filter=lfs diff=lfs merge=lfs -text +a/Curso[[:space:]]de[[:space:]]Introducción[[:space:]]al[[:space:]]Álgebra[[:space:]]Lineal[[:space:]]Vectores/03-Funciones[[:space:]]lineales/03-Teoremas[[:space:]]y[[:space:]]Corolarios[[:space:]]en[[:space:]]Funciones[[:space:]]Lineales.mp4 filter=lfs diff=lfs merge=lfs -text diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/05-Resumen.html" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/05-Resumen.html" new file mode 100644 index 0000000000000000000000000000000000000000..555b400c44e4a85d67cb2561f046b1ad2a3551e0 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/05-Resumen.html" @@ -0,0 +1,143 @@ + + + + + + + Suma de Vectores en Python con NumPy + + + +
+
+

Resumen

¿Cómo sumar vectores en Python?

+

En el emocionante mundo de la programación, la manipulación de vectores es una habilidad clave, especialmente cuando estamos trabajando en Python. Hoy te guiaré a través de cómo realizar operaciones de suma de vectores en este lenguaje de programación, enfatizando la importancia de librerías como NumPy.

+

¿Por qué necesitamos una función específica para la suma de vectores?

+

En Python, cuando utilizamos la operación de suma entre listas, el resultado es la concatenación de estas en lugar de una suma elemento a elemento. Esta peculiaridad de las listas en Python nos obliga a crear una función que tome dos listas y realice la suma correspondiente entre cada elemento.

+

Por ejemplo, al sumar las listas rojo y negro, en donde:

+
    +
  • rojo = [255, 0, 0]
    • +
  • negro = [0, 0, 0]
    • +
+

El operador + concatenaría las listas resultando en [255, 0, 0, 0, 0, 0], lo cual no es deseado.

+

Podemos solucionar esto definiendo una función llamada suma_vectores que sumará los elementos correspondiente entre dos vectores. Aquí un ejemplo en Python:

+
def suma_vectores(a, b):
+    return [i + j for i, j in zip(a, b)]
+
+# Uso de la función
+rojo = [255, 0, 0]
+negro = [0, 0, 0]
+resultado = suma_vectores(rojo, negro)
+print(resultado)  # Salida: [255, 0, 0]
+
+

¿Cómo utilizar NumPy para operar vectores de manera eficiente?

+

NumPy redefine cómo interactuamos con vectores gracias a sus ndarray, que permiten ejecutar operaciones algebraicas directamente, evitando la necesidad de crear funciones específicas y manuales.

+

Para iniciar, importamos el módulo:

+
import numpy as np
+
+

Luego, transformamos las listas en numpy arrays para facilitar las operaciones:

+
rojo = np.array([255, 0, 0])
+negro = np.array([0, 0, 0])
+resultado = rojo + negro
+print(resultado)  # Salida: [255, 0, 0]
+
+

NumPy no sólo simplifica la suma de vectores, sino que también es mucho más eficiente y veloz a largo plazo, manejando operaciones complejas con facilidad mediante algoritmos optimizados.

+

¿Cuál es la diferencia con la implementación manual?

+

El uso de NumPy no solo hace el código más limpio y legible, sino que optimiza la eficiencia computacional. Volvamos al ejemplo de suma algebraica de vectores más elaborados:

+
a = np.array([1, 2, 3, 4, 5])
+b = np.array([-1, -2, -3, -4, 5])
+c = a + b
+print(c)  # Salida: [0, 0, 0, 0, 10]
+
+

El resultado es inmediato, reflejando lo que esperaríamos al operar manualmente. NumPy automatiza las iteraciones que implementaríamos con una función manual de suma, economizando tiempo y recursos.

+

¿Cómo puedes aplicar este conocimiento en desafíos y ejercicios?

+

Te invito a explorar más sumas de vectores aplicando lo aprendido. Atrévete a crear y sumar tus vectores, y verifica cómo cambian los resultados al alternar entre operaciones manuales y NumPy. Un ejemplo práctico podría ser el uso del modelo RGB, determinando qué color resultará al combinar distintos vectores.

+

Ve al sitio donde probamos combinaciones RGB, inserta el resultado de tus sumas y observa su representación en color. Además, intenta responder las siguientes preguntas con tus pruebas:

+
    +
  • ¿Qué color obtienes al sumar rojo y verde?
    • +
  • ¿Qué sucede al sumar negro y -a?
    • +
  • ¿Cómo afectan estas operaciones al modelo RGB?
    • +
+

A través de la práctica, la comunidad de la programación está para ayudarte. Comparte tus hallazgos y preguntas para recibir apoyo, expandir tu conocimiento y disfrutar de este fascinante maratón de aprendizaje. Recuerda, no estás solo en este viaje. ¡Sigue adelante!

+
+
+ + \ No newline at end of file diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Lecturas recomendadas.txt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Lecturas recomendadas.txt" new file mode 100644 index 0000000000000000000000000000000000000000..dd43fff4214bd4427e0b7f818703bc7d1260766f --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Lecturas recomendadas.txt" @@ -0,0 +1 @@ +https://colab.research.google.com/drive/1uF1QvMQBR9B-UPPUKg8d4DVuZNROqUA_?usp=sharing diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Producto EscalarVectores Conceptos y Propiedades B\303\241sicas.mp4" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Producto EscalarVectores Conceptos y Propiedades B\303\241sicas.mp4" new file mode 100644 index 0000000000000000000000000000000000000000..0d513e9ca4666291d9f5d1c07e4b217d2b752dbf --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Producto EscalarVectores Conceptos y Propiedades B\303\241sicas.mp4" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69267f4e501e1dd6c0f7f691293c3b5d98da9d582ede0e28e05b28692c8eeafc +size 156539143 diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Producto EscalarVectores Conceptos y Propiedades B\303\241sicas.vtt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Producto EscalarVectores Conceptos y Propiedades B\303\241sicas.vtt" new file mode 100644 index 0000000000000000000000000000000000000000..bb40ad707c06899a9e221f4056e0d7aca73b0afb --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Producto EscalarVectores Conceptos y Propiedades B\303\241sicas.vtt" @@ -0,0 +1,883 @@ +WEBVTT + +00:00:03.120 --> 00:00:05.759 +Hola, te doy la bienvenida de nuevo. Quizá + +00:00:05.759 --> 00:00:08.100 +no te das cuenta, pero ya hemos avanzado + +00:00:08.160 --> 00:00:10.960 +una gran parte de este camino. Lo que + +00:00:10.960 --> 00:00:14.705 +veremos hoy es el producto entre escalares y + +00:00:14.705 --> 00:00:18.305 +vectores. Antes ya vimos una operación entre vectores, + +00:00:18.305 --> 00:00:20.625 +que era la suma. En este vamos a + +00:00:20.625 --> 00:00:23.904 +ver cómo podemos relacionar los escalares y los + +00:00:23.904 --> 00:00:26.510 +vectores. Vamos a hacer un poco de memoria, + +00:00:26.810 --> 00:00:29.130 +revisitemos los conceptos o lo que hemos visto + +00:00:29.130 --> 00:00:32.090 +rápidamente. Vimos lo que era un vector y + +00:00:32.090 --> 00:00:34.890 +vimos también lo que era un escalar. Dijimos + +00:00:34.890 --> 00:00:36.650 +que un vector era una lista finita de + +00:00:36.650 --> 00:00:42.045 +coeficientes o una lista finita de elementos, mientras + +00:00:42.045 --> 00:00:44.524 +que el escalar se refería un a un + +00:00:44.524 --> 00:00:48.045 +único elemento, a un único número. También vimos + +00:00:48.045 --> 00:00:51.425 +que los escalares son elementos de los campos + +00:00:51.805 --> 00:00:55.150 +escalares, de los campos, y vimos que los + +00:00:55.150 --> 00:01:00.250 +vectores son elementos de los espacios vectoriales. Vimos + +00:01:00.750 --> 00:01:04.430 +cómo operar entre dos elementos de un espacio + +00:01:04.430 --> 00:01:07.115 +vectorial, la suma entre vectores, por ejemplo, y + +00:01:07.115 --> 00:01:10.575 +de misma manera vimos el modelo auditivo RGB. + +00:01:11.195 --> 00:01:13.295 +Ahora vamos a ir un poco más allá. + +00:01:14.715 --> 00:01:17.515 +Vamos a ver cómo tomar un elemento del + +00:01:17.515 --> 00:01:19.674 +campo escalar y vamos a ver cómo tomar + +00:01:19.674 --> 00:01:22.870 +un elemento del espacio vectorial y combinarlos. De + +00:01:22.870 --> 00:01:25.590 +igual manera, vamos a ver más adelante cuál + +00:01:25.590 --> 00:01:29.590 +es la interpretación geométrica de todo esto. Sin + +00:01:29.590 --> 00:01:33.510 +más, vamos a la computadora. Este notebook es + +00:01:33.510 --> 00:01:36.315 +un nuevo notebook, no te preocupes para nada, + +00:01:36.395 --> 00:01:38.395 +lo vas a tener disponible siempre y vas + +00:01:38.395 --> 00:01:40.975 +a poder consultarlo siempre que lo quieras consultar. + +00:01:42.075 --> 00:01:46.715 +Así bien, vamos a empezar definiendo lo que + +00:01:46.715 --> 00:01:49.740 +va a ser la multiplicación escalar vector. En + +00:01:49.740 --> 00:01:53.209 +este caso, simplemente tomemos un vector, un n + +00:01:53.209 --> 00:01:56.678 +vector b cualquiera, es decir, un vector de + +00:01:56.678 --> 00:02:01.020 +RNY alfa un escalar del campo de los + +00:02:01.020 --> 00:02:05.365 +reales, y definamos, a su vez, el vector + +00:02:05.424 --> 00:02:09.425 +x como la multiplicación de el escalar alfa + +00:02:09.425 --> 00:02:14.145 +por el vector b. Si recordamos de las + +00:02:14.145 --> 00:02:18.659 +clases pasadas, nosotros hablamos de notación y dijimos + +00:02:18.659 --> 00:02:21.060 +que en algunos casos íbamos a reservar el + +00:02:21.060 --> 00:02:24.500 +uso de letras griegas para escalares. Este es + +00:02:24.500 --> 00:02:29.215 +el caso. Ahora, ¿cómo se ven los elementos + +00:02:29.215 --> 00:02:34.015 +de x? Como alfa es un escalar y + +00:02:34.015 --> 00:02:36.975 +b es un n vector, la combinación de + +00:02:36.975 --> 00:02:39.135 +alfa y b nos tiene que dar un + +00:02:39.135 --> 00:02:42.030 +n vector, es decir, alfa por beta nos + +00:02:42.030 --> 00:02:44.270 +da un n vector, y ese vector, en + +00:02:44.270 --> 00:02:47.310 +este caso, será el vector x. ¿Cómo se + +00:02:47.310 --> 00:02:51.470 +ve entrada por entrada? Bueno, alfa por b + +00:02:51.470 --> 00:02:54.444 +no es más que alfa por este vector, + +00:02:54.505 --> 00:02:57.385 +que es exactamente el b, v cero, v + +00:02:57.385 --> 00:03:00.745 +uno, hasta b n menos uno. Recordemos que + +00:03:00.745 --> 00:03:02.905 +como tiene dimensión n, es decir, es un + +00:03:02.905 --> 00:03:08.180 +n vector, las entradas corren de desde el + +00:03:08.180 --> 00:03:11.459 +cero hasta el n menos uno. ¿Y cómo + +00:03:11.459 --> 00:03:13.780 +se verán las entradas de x? Pues simplemente + +00:03:13.780 --> 00:03:17.159 +será la primera entrada alfa por b cero, + +00:03:17.700 --> 00:03:20.345 +alfa por b cero, la segunda entrada de + +00:03:20.345 --> 00:03:23.224 +x será alfa por b uno, la tercera + +00:03:23.224 --> 00:03:25.644 +será alfa por b dos, y la enésima + +00:03:26.185 --> 00:03:28.605 +entrada será alfa por b n menos uno. + +00:03:30.025 --> 00:03:33.004 +Como ejemplo concreto, pensemos en el vector b + +00:03:33.144 --> 00:03:37.010 +igual a cero coma uno coma menos dos + +00:03:37.010 --> 00:03:39.570 +punto tres, y pensemos que alfa es igual + +00:03:39.570 --> 00:03:43.410 +al menos uno punto uno. Entonces, si nosotros + +00:03:43.410 --> 00:03:47.010 +multiplicamos entrada por entrada, deberíamos de obtener este + +00:03:47.010 --> 00:03:53.118 +vector de aquí, vamos a comprobarlo. Ahora, en + +00:03:53.118 --> 00:03:57.545 +Python podemos hacer operaciones entre escalares sin necesidad + +00:03:57.545 --> 00:04:00.285 +de llamar a NumPy, entonces vamos a corroborar + +00:04:00.665 --> 00:04:03.705 +entrada por entrada. Sabemos que la primera entrada + +00:04:03.705 --> 00:04:05.920 +debería de ser cero, que es este número + +00:04:05.920 --> 00:04:10.320 +de aquí, por menos uno punto uno, que + +00:04:10.320 --> 00:04:13.060 +es nuestro escalar, y eso nos da efectivamente + +00:04:13.600 --> 00:04:16.640 +cero. Para fines prácticos, el menos cero o + +00:04:16.640 --> 00:04:20.014 +el cero será el cero simplemente. El menos + +00:04:20.014 --> 00:04:22.735 +aparece aquí como una representación de los números + +00:04:22.735 --> 00:04:25.215 +dentro de Python, pero no te preocupes, cero + +00:04:25.215 --> 00:04:27.775 +y menos cero juegan el mismo papel. En + +00:04:27.775 --> 00:04:30.835 +la realidad no existe el menos cero, simplemente + +00:04:31.055 --> 00:04:35.780 +existe el cero. Ahora veamos la siguiente entrada + +00:04:35.780 --> 00:04:37.780 +que es el uno, uno por menos uno + +00:04:37.780 --> 00:04:40.100 +punto uno nos debería de dar exactamente menos + +00:04:40.100 --> 00:04:43.220 +uno punto uno, y justamente es esta entrada + +00:04:43.220 --> 00:04:46.979 +de acá. Y por último tenemos esta entrada + +00:04:46.979 --> 00:04:51.205 +que es menos dos punto cincuenta y tres. + +00:04:51.205 --> 00:04:54.485 +Veamos que esto sale de multiplicar menos dos + +00:04:54.485 --> 00:04:57.525 +punto tres por menos uno punto uno. Menos + +00:04:57.525 --> 00:05:00.345 +dos punto tres, nos falta acá un menos, + +00:05:00.730 --> 00:05:03.530 +por menos uno punto tres, y exactamente nos + +00:05:03.530 --> 00:05:06.490 +da dos punto cincuenta y tres. Te invito + +00:05:06.490 --> 00:05:09.050 +a que pienses en Python como tu herramienta, + +00:05:09.050 --> 00:05:12.730 +como tu calculadora, como tu forma de sumar, + +00:05:12.730 --> 00:05:15.170 +para que te empieces a familiarizar más y + +00:05:15.170 --> 00:05:18.195 +empieces a soltar los dedos, como a veces + +00:05:18.195 --> 00:05:21.555 +decimos en matemáticas soltar las manos escribiendo, en + +00:05:21.555 --> 00:05:25.655 +Python se hará soltar los dedos programando. Ahora, + +00:05:26.115 --> 00:05:28.675 +vamos a ver qué propiedades cumple el producto + +00:05:28.675 --> 00:05:35.140 +escalar vector. Consideremos dos vectores cualesquiera XYYY también + +00:05:35.140 --> 00:05:39.640 +consideremos dos escalares cualesquiera alfa y beta, ¿vale? + +00:05:40.740 --> 00:05:44.440 +Recordemos aquí que XYY ambos son n vectores. + +00:05:45.544 --> 00:05:47.544 +Ahora, una de las propiedades que va a + +00:05:47.544 --> 00:05:50.185 +cumplir la multiplicación de un escalar por un + +00:05:50.185 --> 00:05:53.065 +vector es la conmutatividad. Si la recordamos de + +00:05:53.065 --> 00:05:56.264 +operaciones pasadas como la suma, sabíamos que si + +00:05:56.264 --> 00:05:58.860 +sumamos un vector x más un vector y, + +00:05:59.020 --> 00:06:01.020 +era exactamente lo mismo que sumar el vector + +00:06:01.020 --> 00:06:03.340 +y más un vector x. En el caso + +00:06:03.340 --> 00:06:06.300 +de la conmutatividad de un escalar vector, de + +00:06:06.300 --> 00:06:08.479 +una de un producto escalar por un vector, + +00:06:08.620 --> 00:06:12.300 +tenemos que alfa por x es igual que + +00:06:12.300 --> 00:06:15.845 +x por alfa. En el caso de la + +00:06:15.845 --> 00:06:23.385 +asociatividad, tenemos que beta por alfa por x + +00:06:23.445 --> 00:06:26.185 +va a ser exactamente lo mismo que beta + +00:06:26.565 --> 00:06:30.140 +alfa veces x. Una cosa interesante es que + +00:06:30.140 --> 00:06:32.700 +esto de aquí lo podemos leer como alfa + +00:06:32.700 --> 00:06:35.120 +veces x, y más adelante en la interpretación + +00:06:35.580 --> 00:06:39.420 +geométrica veremos por qué. Ahora, la sociatividad es + +00:06:39.420 --> 00:06:41.580 +una propiedad muy interesante porque nos dice que + +00:06:41.580 --> 00:06:46.354 +da lo mismo que multipliquemos beta por alfa + +00:06:46.354 --> 00:06:49.074 +veces x, que si multiplicamos beta y alfa + +00:06:49.074 --> 00:06:51.395 +al mismo tiempo, y después el resultado lo + +00:06:51.395 --> 00:06:55.875 +multiplicamos por x. Ahora, está la propiedad de + +00:06:55.875 --> 00:06:58.995 +la distribución y tenemos distribución sobre una suma + +00:06:58.995 --> 00:07:01.610 +escalar y tenemos una distribución sobre una suma + +00:07:01.610 --> 00:07:03.530 +de vectores. En el caso de la suma + +00:07:03.530 --> 00:07:06.250 +escalar, consideremos la suma de los escalares alfa + +00:07:06.250 --> 00:07:08.690 +más beta. En el caso de los escalares + +00:07:08.690 --> 00:07:12.090 +alfa más beta, el resultado será multiplicado a + +00:07:12.090 --> 00:07:15.615 +x, pero notemos que en este caso podemos + +00:07:16.155 --> 00:07:19.195 +expresar esta operación de aquí como alfa veces + +00:07:19.195 --> 00:07:24.235 +x más beta veces x, ¿vale? Entonces da + +00:07:24.235 --> 00:07:26.555 +lo mismo si sumamos los escalares y después + +00:07:26.555 --> 00:07:31.330 +se lo multiplicamos AX0 bien si sumamos alfa + +00:07:31.330 --> 00:07:33.350 +veces x, es decir, la multiplicación del escalar + +00:07:34.130 --> 00:07:36.850 +alfa por el vector x, y después le + +00:07:36.850 --> 00:07:42.475 +sumamos beta por el escalar x. Ahora, por + +00:07:42.475 --> 00:07:45.355 +propiedades de la conmutatividad de la suma, esto + +00:07:45.355 --> 00:07:49.215 +lo podemos escribir también como beta por x + +00:07:49.715 --> 00:07:55.130 +más alfa por XYA su vez, esto lo + +00:07:55.130 --> 00:08:01.450 +podemos expresar como x por alfa más beta, + +00:08:01.450 --> 00:08:03.790 +lo cual cumple la propiedad de la conmutatividad + +00:08:04.090 --> 00:08:07.770 +también. Entonces, alfa más beta por x es + +00:08:07.770 --> 00:08:11.305 +exactamente igual que x por alfa más beta. + +00:08:12.805 --> 00:08:15.764 +Por último, veamos la distribución sobre una suma + +00:08:15.764 --> 00:08:19.604 +de vectores. Consideramos que tenemos este escalar alfa + +00:08:19.604 --> 00:08:22.260 +y estamos sumando los vectores x más y. + +00:08:22.340 --> 00:08:24.660 +Por eso, cuando definimos a los vectores x + +00:08:24.660 --> 00:08:26.420 +más y, era importante que los dos fueran + +00:08:26.420 --> 00:08:29.780 +n vectores. Recordemos que no podemos sumar vectores + +00:08:29.780 --> 00:08:32.179 +de diferente dimensión, tienen que ser de la + +00:08:32.179 --> 00:08:36.085 +misma dimensión para poder sumarlos. Ahora bien, consideremos + +00:08:36.385 --> 00:08:39.424 +alfa por x más y. Alfa por x + +00:08:39.424 --> 00:08:42.145 +más y, es decir, sumarlos y después a + +00:08:42.145 --> 00:08:45.505 +la suma de estos vectores multiplicarles alfa, es + +00:08:45.505 --> 00:08:50.145 +exactamente igual que x que alfa por x + +00:08:50.145 --> 00:08:53.190 +más alfa por y, es decir, que la + +00:08:53.190 --> 00:08:56.630 +suma de la multiplicación de los escalares de + +00:08:56.630 --> 00:09:01.269 +manera individual por los vectores, ¿vale? Más adelante + +00:09:01.269 --> 00:09:06.385 +comprobaremos que esto se cumple también computacionalmente. Ahora + +00:09:06.385 --> 00:09:09.905 +vamos a algunas consideraciones. En esas consideraciones vamos + +00:09:09.905 --> 00:09:14.545 +a ver una forma particular de multiplicación de + +00:09:14.545 --> 00:09:17.665 +escalares por vectores. La primera que vamos a + +00:09:17.665 --> 00:09:20.829 +ver se llama combinación lineal o combinaciones lineales + +00:09:20.829 --> 00:09:23.389 +en plural, y en este caso vamos a + +00:09:23.389 --> 00:09:26.670 +considerar m vectores. A estos m vectores les + +00:09:26.670 --> 00:09:29.389 +vamos a llamar a cero, a uno, hasta + +00:09:29.389 --> 00:09:33.230 +el vector a m menos uno. Y estos + +00:09:33.230 --> 00:09:37.125 +m vectores, estos m vectores son n vectores, + +00:09:37.125 --> 00:09:40.524 +es decir, tenemos m vectores, m cantidad de + +00:09:40.524 --> 00:09:42.925 +vectores, y cada uno de estos vectores es + +00:09:42.925 --> 00:09:48.225 +un n vector. Y consideremos también que tenemos + +00:09:48.524 --> 00:09:51.860 +n escalares que van desde beta cero hasta + +00:09:51.860 --> 00:09:56.580 +beta m menos uno. Con estos escalares y + +00:09:56.580 --> 00:10:00.279 +estos vectores podemos definir el siguiente n vector. + +00:10:00.900 --> 00:10:03.620 +Recordemos que si estamos sumando dos n vectores, + +00:10:03.620 --> 00:10:05.925 +el resultado es un n vector, y si + +00:10:06.465 --> 00:10:09.825 +multiplicamos escalares por ese n vector, nos va + +00:10:09.825 --> 00:10:12.705 +a dar otra vez un n vector. Entonces, + +00:10:12.705 --> 00:10:16.625 +definimos por eso este n vector, en donde + +00:10:16.625 --> 00:10:19.505 +el escalar beta cero se va a multiplicar + +00:10:19.505 --> 00:10:23.649 +con el vector a cero. El escalar beta + +00:10:23.649 --> 00:10:25.810 +uno se va a multiplicar con el vector + +00:10:25.810 --> 00:10:30.310 +a uno, y así hasta el escalar beta + +00:10:30.370 --> 00:10:32.209 +m menos uno, que se va a multiplicar + +00:10:32.209 --> 00:10:35.055 +con el vector a m menos uno. A + +00:10:35.055 --> 00:10:38.535 +este vector se le llama una combinación lineal + +00:10:38.535 --> 00:10:41.535 +y es una combinación lineal de los vectores + +00:10:41.535 --> 00:10:44.735 +a cero hasta am menos uno, y a + +00:10:44.735 --> 00:10:47.650 +los escalares de la combinación lineal se le + +00:10:47.650 --> 00:10:50.930 +llaman coeficientes de la combinación lineal, es decir, + +00:10:50.930 --> 00:10:54.290 +los coeficientes de esta combinación lineal son los + +00:10:54.290 --> 00:10:57.010 +escalares b cero, p uno, hasta el b + +00:10:57.010 --> 00:11:01.345 +m menos uno. Hay combinaciones lineales que son + +00:11:01.345 --> 00:11:04.485 +especiales y, además, las combinaciones lineales nos permiten + +00:11:04.625 --> 00:11:08.705 +expresar cosas de formas importantes. Por ejemplo, nosotros + +00:11:08.705 --> 00:11:11.905 +tenemos una combinación lineal especial y es la + +00:11:11.905 --> 00:11:15.110 +combinación lineal de vectores unitarios, Y en la + +00:11:15.110 --> 00:11:17.690 +realidad es que va a ser posible expresar + +00:11:17.830 --> 00:11:22.390 +cualquier vector b, cualquier nvector b, como combinación + +00:11:22.390 --> 00:11:26.070 +lineal de los vectores unitarios estándar. Consideremos entonces + +00:11:26.070 --> 00:11:29.285 +que tenemos el vector b. Este vector tiene + +00:11:29.285 --> 00:11:31.365 +entradas de cero, v uno, v dos, v + +00:11:31.365 --> 00:11:33.285 +tres, hasta v n menos uno, porque es + +00:11:33.285 --> 00:11:37.145 +un n vector. Aquí podemos considerar y llamar + +00:11:37.525 --> 00:11:40.725 +entonces a los vectores unitarios d a los + +00:11:40.725 --> 00:11:45.410 +n vectores unitarios. Entonces, si recordamos cómo son + +00:11:45.410 --> 00:11:49.990 +los vectores unitarios, son aquellos vectores e, I, + +00:11:50.450 --> 00:11:52.850 +en donde la única entrada que no es + +00:11:52.850 --> 00:11:56.770 +cero es la iésima, y la iésima es + +00:11:56.770 --> 00:11:59.995 +igual a uno. En este caso, vamos a + +00:11:59.995 --> 00:12:03.615 +poder expresar al vector b como la suma + +00:12:04.074 --> 00:12:07.274 +de estos coeficientes b cero, que son los + +00:12:07.274 --> 00:12:12.740 +del vector, por el vector unitario correspondiente a + +00:12:12.740 --> 00:12:15.880 +esa entrada, es decir, b cero lo multiplicaremos + +00:12:16.260 --> 00:12:18.660 +por el vector unitario e cero, que es + +00:12:18.660 --> 00:12:22.020 +aquel en donde la primer entrada es igual + +00:12:22.020 --> 00:12:24.375 +a uno y las demás son cero. B + +00:12:24.375 --> 00:12:26.715 +uno lo vamos a multiplicar por el vector + +00:12:27.175 --> 00:12:29.255 +unitario uno o el e uno, en donde + +00:12:29.255 --> 00:12:30.935 +la segunda entrada es un uno y todas + +00:12:30.935 --> 00:12:33.735 +las demás son cero, y así hasta el + +00:12:33.735 --> 00:12:38.535 +enésimo vector unitario e n menos uno por + +00:12:38.535 --> 00:12:44.310 +el enésimo coeficiente b n menos uno, que + +00:12:44.310 --> 00:12:47.130 +es la enésima entrada de este vector b. + +00:12:48.870 --> 00:12:51.450 +Ahora, vamos a poner un ejemplo de esto. + +00:12:52.595 --> 00:12:58.514 +Consideremos el vector uno menos uno cero. Esto + +00:12:58.514 --> 00:13:03.154 +lo podemos expresar en término de las de + +00:13:03.154 --> 00:13:07.190 +los vectores unitarios, de los tres vectores unitarios, + +00:13:07.650 --> 00:13:10.610 +que sería el uno cero cero, el cero + +00:13:10.610 --> 00:13:13.970 +uno cero y el cero cero uno. ¿Cómo + +00:13:13.970 --> 00:13:17.770 +lo podemos expresar? Bueno, para la primera entrada + +00:13:17.850 --> 00:13:21.495 +nosotros multiplicaremos el escalar uno, y entonces uno + +00:13:21.495 --> 00:13:24.454 +por uno cero cero nos da exactamente esta + +00:13:24.454 --> 00:13:28.135 +entrada de aquí. En el caso del cero + +00:13:28.135 --> 00:13:31.415 +uno cero, lo multiplicaremos por un menos uno, + +00:13:31.415 --> 00:13:36.029 +y eso significará que cuando sumemos este más + +00:13:36.029 --> 00:13:42.350 +este nos dará el uno menos uno por + +00:13:42.350 --> 00:13:46.690 +menos uno por uno, y un cero. Ahora, + +00:13:46.995 --> 00:13:51.395 +para el último de los vectores unitarios, lo + +00:13:51.395 --> 00:13:54.595 +multiplicaremos por un cero, y esto nos dará + +00:13:54.595 --> 00:13:57.555 +un cero exactamente aquí, así que cuando sumemos + +00:13:57.555 --> 00:14:00.675 +los tres, nos dará el vector uno menos + +00:14:00.675 --> 00:14:05.360 +uno cero. Te invito a que compruebes que + +00:14:05.360 --> 00:14:08.480 +esto se cumple de manera efectiva haciendo esta + +00:14:08.480 --> 00:14:12.320 +operación a mano. Ahora, hay una cosa muy + +00:14:12.320 --> 00:14:14.320 +importante, y es que hay que denotar que + +00:14:14.320 --> 00:14:17.425 +para un espacio vectorial de dimensión n, es + +00:14:17.425 --> 00:14:20.645 +decir, donde viven n vectores, vamos a tener + +00:14:20.785 --> 00:14:24.465 +n vectores unitarios e uno. Es decir, para + +00:14:24.465 --> 00:14:30.215 +el espacio vectorial de dimensión dos, el r + +00:14:30.215 --> 00:14:33.750 +dos, por ejemplo, tendremos, en donde viven dos + +00:14:33.750 --> 00:14:37.509 +vectores, tenemos dos vectores unitarios, el cero, el + +00:14:37.509 --> 00:14:39.350 +e cero y el e uno. En el + +00:14:39.350 --> 00:14:41.990 +caso de r tres o un espacio vectorial + +00:14:41.990 --> 00:14:45.715 +de dimensión tres, tendremos tres vectores unitarios, el + +00:14:45.715 --> 00:14:47.735 +e cero, el e uno y el e + +00:14:47.795 --> 00:14:51.575 +dos, y así hasta espacios vectoriales de dimensión + +00:14:51.955 --> 00:14:55.235 +n, donde tendremos bases e cero, e uno, + +00:14:55.235 --> 00:15:00.709 +e dos hasta n menos uno. Si no + +00:15:00.709 --> 00:15:03.589 +recuerdas la construcción de estos vectores unitarios, te + +00:15:03.589 --> 00:15:06.310 +invito a que repases las clases anteriores, ya + +00:15:06.310 --> 00:15:08.870 +que vimos una forma sencilla y fácil de + +00:15:08.870 --> 00:15:13.385 +poder construirlos. Ahora, vamos a ver algunas combinaciones + +00:15:14.085 --> 00:15:17.445 +lineales especiales. Algunas de esas combinaciones serán, por + +00:15:17.445 --> 00:15:20.645 +ejemplo, aquellas en donde los coeficientes de la + +00:15:20.645 --> 00:15:23.925 +combinación lineal, todos los coeficientes sean igual a + +00:15:23.925 --> 00:15:27.290 +uno. Eso quiere decir que simplemente estaremos hablando + +00:15:27.290 --> 00:15:30.330 +de una suma de vectores. Es decir, si + +00:15:30.330 --> 00:15:33.530 +en esta combinación lineal, beta cero, beta uno, + +00:15:33.530 --> 00:15:35.690 +beta dos, hasta beta m menos uno son + +00:15:35.690 --> 00:15:38.865 +igual a uno, simplemente estaríamos sumando los vectores + +00:15:39.085 --> 00:15:40.765 +a cero, a uno, hasta el a m + +00:15:40.765 --> 00:15:43.165 +menos uno, es decir, una suma normal de + +00:15:43.165 --> 00:15:52.070 +vectores. Ahora bien, si todos nuestros coeficientes son + +00:15:52.070 --> 00:15:56.230 +igual a uno entre m, beta cero, beta + +00:15:56.230 --> 00:15:58.310 +uno, hasta beta m menos uno igual a + +00:15:58.310 --> 00:16:01.110 +uno entre m, a esta combinación lineal se + +00:16:01.110 --> 00:16:07.178 +le llamará promedio de vectores. Y, en cambio, + +00:16:07.265 --> 00:16:10.785 +si nuestros coeficientes suman uno, es decir, b + +00:16:10.785 --> 00:16:13.185 +cero más b uno más b dos hasta + +00:16:13.185 --> 00:16:15.445 +el b m menos uno nos da un + +00:16:15.585 --> 00:16:18.464 +uno, entonces a esta combinación lineal le llamaremos + +00:16:18.464 --> 00:16:22.519 +combinación afín, y cuando los coeficientes b y + +00:16:22.519 --> 00:16:26.360 +sean todos no negativos, es decir, todos estos + +00:16:26.360 --> 00:16:28.360 +b cero, b uno, hasta el b m + +00:16:28.360 --> 00:16:32.220 +menos uno, sean positivos, entonces la combinación lineal + +00:16:32.755 --> 00:16:36.035 +será una mezcla, una combinación convexa o un + +00:16:36.035 --> 00:16:40.355 +promedio pesado, esos nombres son intercambiables. Muy bien, + +00:16:40.355 --> 00:16:44.115 +hasta aquí llegó esta clase. La próxima clase + +00:16:44.115 --> 00:16:47.879 +será una clase práctica y una clase geométrica, + +00:16:47.939 --> 00:16:50.679 +una clase ilustrativa, de cómo se ve la + +00:16:50.979 --> 00:16:54.499 +multiplicación de escalar por las por vectores. Te + +00:16:54.499 --> 00:16:55.879 +espero en la próxima clase. diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Resumen.html" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Resumen.html" new file mode 100644 index 0000000000000000000000000000000000000000..9a113073bed15703b822e759c5ad77247d08976e --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-Resumen.html" @@ -0,0 +1,137 @@ + + + + + + + Producto Escalar-Vectores: Conceptos y Propiedades Básicas + + + +
+
+

Resumen

¿Qué es el producto entre escalares y vectores?

+

El producto entre escalares y vectores es una operación fundamental en álgebra lineal que permite combinar elementos de diferentes espacios matemáticos. Mientras que los vectores son listas finitas de elementos que pertenecen a espacios vectoriales, los escalares son números individuales que forman parte de campo de escalares. Esta operación es clave para vincular estos dos conceptos de manera efectiva.

+

¿Cómo se define la multiplicación escalar vector?

+

En este contexto, tomamos un vector ( b ) de dimensión n (llamado n vector) y un escalar (\alpha). La operación resultante, ( x ), se describe como la multiplicación de (\alpha) con ( b ). Se expresa entrada por entrada: cada elemento de ( b ) se multiplica por (\alpha). Por ejemplo, si el vector ( b = (0, 1, -2.3) ) y (\alpha = -1.1), el resultado será un nuevo vector calculado multiplicando cada elemento del vector por (\alpha).

+
# Ejemplo en Python sin necesidad de librerías adicionales como NumPy
+b = [0, 1, -2.3]
+alpha = -1.1
+
+# Producto escalar
+x = [alpha * entry for entry in b]
+print(x)  # Salida: [-0.0, -1.1, 2.53]
+
+

¿Qué propiedades cumple el producto escalar vector?

+

La multiplicación de un escalar con un vector se rige por varias propiedades fundamentales:

+
    +
  • Conmutatividad: (\alpha \cdot x = x \cdot \alpha)
    • +
  • Asociatividad: ((\beta \cdot \alpha) \cdot x = \beta \cdot (\alpha \cdot x))
    • +
  • Distribución sobre suma escalar: ((\alpha + \beta) \cdot x = \alpha \cdot x + \beta \cdot x)
    • +
  • Distribución sobre suma de vectores: (\alpha \cdot (x + y) = \alpha \cdot x + \alpha \cdot y)
    • +
+

Estas propiedades aseguran el correcto comportamiento de la multiplicación en diversas operaciones vectoriales.

+

¿Qué son las combinaciones lineales?

+

Las combinaciones lineales permiten expresar un vector como una suma ponderada de varios vectores. Dada una colección de ( m ) vectores y ( n ) escalares, se forma un nuevo vector sumando cada escalar multiplicado por su correspondiente vector.

+

Un aspecto especial de las combinaciones lineales es la posibilidad de expresar cualquier vector como combinación de vectores unitarios, los cuales tienen un único uno en una posición y ceros en otras.

+

Ejemplo:

+

Considera el vector ( (1, -1, 0) ), que se puede representar usando vectores unitarios:

+
    +
  • ( e_0 = (1, 0, 0) )
    • +
  • ( e_1 = (0, 1, 0) )
    • +
  • ( e_2 = (0, 0, 1) )
    • +
+

La representación sería: +[ 1 \cdot e_0 + (-1) \cdot e_1 + 0 \cdot e_2 = (1, -1, 0) ]

+

¿Cuáles son las combinaciones lineales especiales?

+

Existen combinaciones lineales con características distintivas:

+
    +
  • Suma de vectores: Se da cuando todos los coeficientes son 1.
    • +
  • Promedio de vectores: Cuando todos los coeficientes son ( \frac{1}{m} ).
    • +
  • Combinación afín: Cuando la suma de los coeficientes es igual a 1.
    • +
  • Combinación convexa o promedio pesado: Cuando los coeficientes son no negativos y suman 1.
    • +
+

Estas operaciones son fundamentales en aplicaciones como mezclas convexas en programación lineal y ponderaciones en análisis de datos.

+

Esta introducción abarca los conceptos esenciales sobre el producto entre escalares y vectores, sus propiedades y la relevancia de las combinaciones lineales. Te animo a experimentar con estos conceptos en Python y seguir explorando sus aplicaciones geométricas en las próximas clases. ¡Sigue practicando y desarrollando tus habilidades matemáticas!

+
+
+ + \ No newline at end of file diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-producto_escalar_383fadd8-6e92-4690-aefe-72a7454fa87a.ipynb" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-producto_escalar_383fadd8-6e92-4690-aefe-72a7454fa87a.ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..9d2662b51f6a4d527352e2d77716032a8fbf3dcf --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/06-producto_escalar_383fadd8-6e92-4690-aefe-72a7454fa87a.ipynb" @@ -0,0 +1,472 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. Producto por un escalar o multiplicación escalar-vector." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Otra operación es el *producto por un escalar* o *multiplicación escalar-vector* en la cual un vector es multiplicado por un escalar. La operación se hace elemento a elemento. Sea $\\vec{v}$ un vector de $\\mathbb{R}^{n}$ y $\\alpha \\in \\mathbb{R}$. Si $\\vec{x} = \\alpha \\vec{v}$ entonces:\n", + "$$\n", + "\\vec{x} = \\alpha \\vec{v} = \\alpha\\begin{bmatrix}v_{0}\\\\ v_{1}\\\\ \\vdots \\\\ v_{n-1}\\end{bmatrix} = \\begin{bmatrix}\\alpha \\cdot v_{0}\\\\ \\alpha \\cdot v_{1}\\\\ \\vdots \\\\ \\alpha \\cdot v_{n-1}\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Por ejemplo, si $\\vec{v} = (0,1,-2.3)$ y $\\alpha = -1.1$ entonces $\\alpha \\vec{v} = (0,-1.1,2.53)$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.1 Propiedades del producto por un escalar-vector" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sean $\\vec{x},\\vec{y}$ dos vectores y $\\alpha, \\beta$ dos escalares cualquiera. Las propiedades que cumple el producto escalar-vector son las siguientes:\n", + "* Conmutatividad: $\\alpha \\vec{x} = \\vec{x}\\alpha $\n", + "\n", + "* Asociatividad: $(\\beta \\alpha)\\vec{x} = \\beta (\\alpha\\vec{x})$\n", + "\n", + "* Distribución sobre suma escalar: $(\\alpha + \\beta)\\vec{x} = \\alpha \\vec{x} + \\beta\\vec{x} =\\beta\\vec{x} + \\alpha\\vec{x} = \\vec{x}(\\alpha + \\beta) $\n", + "\n", + "* Distribución sobre suma de vectores: $\\alpha (\\vec{x}+\\vec{y}) = \\alpha\\vec{x} + \\alpha\\vec{y}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.2 Algunas consideraciones" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Combinaciones lineales**. Sean $\\vec{a}_{0},\\vec{a}_{1},\\dots,\\vec{a}_{m-1}$ $n$-vectores y $\\beta_{0},\\beta_{1},\\dots,\\beta_{m-1}$ escalares entonces podemos definir el siguiente $n$-vector:\n", + "\n", + "$$\n", + "\\beta_{0}\\vec{a}_{0}+\\beta_{1}\\vec{a}_{1}+\\cdots+\\beta_{m-1}\\vec{a}_{m-1}\n", + "$$\n", + "\n", + "Es llamado una *combinación lineal* de los vectores $\\vec{a}_{0},\\vec{a}_{1},\\dots,\\vec{a}_{m-1}$. Los escalares $\\beta_{0},\\beta_{1},\\dots,\\beta_{m-1}$ son llamados los *coeficientes* de la combinación lineal." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Combinaciones lineales de vectores unitarios**. Es posible escribir cualquier $\\vec{b}$ $n$-vector como combinación lineal de los vectores unitarios estándar:\n", + "\n", + "$$\n", + "\\vec{b} = b_{0}\\hat{e}_{0}+b_{1}\\hat{e}_{1} + \\cdots +b_{n-1}\\hat{e}_{n-1}\n", + "$$\n", + "\n", + "Con $b_{i}$ escalares y $\\hat{e}_{i}$ el i-ésimo vector unitario. Un ejemplo específico sería:\n", + "\n", + "$$\n", + "\\begin{bmatrix}1\\\\ -1\\\\ 0\\end{bmatrix} = (1)\\begin{bmatrix}1\\\\ 0\\\\ 0\\end{bmatrix} + (-1)\\begin{bmatrix}0\\\\ 1\\\\ 0\\end{bmatrix} + (0)\\begin{bmatrix}0\\\\ 0\\\\ 1\\end{bmatrix}\n", + "$$\n", + "\n", + "Como nota final aquí, notemos que si el espacio vectorial es de dimensión $n$ entonces tiene $n$ vectores unitarios $\\hat{e}_{i}$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Combinaciones lineales especiales**. Algunas combinaciones de $n$-vectores $\\vec{a}_{0},\\vec{a}_{1},\\dots,\\vec{a}_{m-1}$ tienen nombres especiales. Por ejemplo, si los coeficientes de la combinación lineal son tales que $\\beta_{0}=\\beta_{1}=\\cdots=\\beta_{m-1} = 1$ entonces simplemente es una suma de vectores. Si en cambio $\\beta_{0}=\\beta_{1}=\\cdots=\\beta_{m-1} = 1/m$ entonces la combinación lineal se llama el *promedio de vectores*. \n", + "Cuando $\\beta_{0}+\\beta_{1}+\\cdots+\\beta_{m-1}=1$ entonces la combinación lineal se llama *combinación afín*, cuando los coeficientes $\\beta_{i}$ son no-negativos entonces la combinación lineal es llamada una *mezcla*, *combinación convexa* o un *promedio pesado*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.3 Producto por un escalar-vector en Python" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Desde la clase pasada introducimos Numpy para manejo de vectores. Una de las fortunas de usar numpy sobre listas es la simpleta de este tipo de operaciones. Realizar esta operación será tan sencillo como usar el operador $*$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Partamos del vector $\\vec{x}= (1,-1,1)$ y del escalar $a = 3.1$ entonces, realicemos las operaciones $a\\vec{x}$ y $\\vec{x}a$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np #primero importamos numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.array([1,-1,1]) #declaramos el vector x\n", + "\n", + "a = 3.1 #declaramos el escalar a" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ax es [ 3.1 -3.1 3.1]\n" + ] + } + ], + "source": [ + "print('ax es',a*x)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xa es [ 3.1 -3.1 3.1]\n" + ] + } + ], + "source": [ + "print('xa es',x*a)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "b = -a" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(b+a)x es [ 0. -0. 0.]\n" + ] + } + ], + "source": [ + "print('(b+a)x es',(b+a)*x)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xa+xb es [0. 0. 0.]\n" + ] + } + ], + "source": [ + "print('xa+xb es',b*x+ x*a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora un ejecio más $\\vec{v} = (1,1)$. Si consideramos a = -1, b = 2, c = 0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "v = np.array([1,1])\n", + "a = -1\n", + "b = 2\n", + "c = 0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-1, -1])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v*a" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 2])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v*b" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.1, 0.1])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v*c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.3 Ejercicios" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 1**. Escribe TODOS los vectores unitarios estándar de $\\mathbb{R}^{4}$. *Hint:* son cuatro. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 2**. Escribe tres combinaciones lineales de vectores en $\\mathbb{R}^{3}$ para expresar el vector $[1,1,1]$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 3.** Escribe tres combinaciones afines con vectores de $\\mathbb{R}^{3}$ donde $\\beta_{0}\\neq\\beta_{1}\\neq\\beta_{2}$ pero que se cumpla que $\\beta_{0}+\\beta_{1}+\\beta_{2}=1$. *HINT*: Si no se te ocurre ninguna combinación para los coeficientes la ecuación $\\beta_{0}+\\beta_{1}+\\beta_{2}=1$ tiene infinitas soluciones, puedes hacer un programa para encontrar tres. " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.linspace(0,5,1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.005005005005005005" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[1]-a[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.005005005005005005" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2]-a[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.005005005005005003" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[999]-a[998]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.0" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[999]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Lecturas recomendadas.txt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Lecturas recomendadas.txt" new file mode 100644 index 0000000000000000000000000000000000000000..18bba7a4014ea19258fd6c24d4909373029e7d47 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Lecturas recomendadas.txt" @@ -0,0 +1,2 @@ +https://geogebra.org/calculator +https://colab.research.google.com/drive/1uF1QvMQBR9B-UPPUKg8d4DVuZNROqUA_?usp=sharing diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Operaciones con Escalares y Vectores en Python usando NumPy.mp4" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Operaciones con Escalares y Vectores en Python usando NumPy.mp4" new file mode 100644 index 0000000000000000000000000000000000000000..d7c832237772c8ba9e2c64acafb669ffa92769a5 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Operaciones con Escalares y Vectores en Python usando NumPy.mp4" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:222647ee6ecca2b5541add87fa30960d05381916508c3f0930cca4a2855bd8ce +size 182945717 diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Operaciones con Escalares y Vectores en Python usando NumPy.vtt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Operaciones con Escalares y Vectores en Python usando NumPy.vtt" new file mode 100644 index 0000000000000000000000000000000000000000..a5a2b9811624d68378462e8941c05588f3dfec3e --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Operaciones con Escalares y Vectores en Python usando NumPy.vtt" @@ -0,0 +1,883 @@ +WEBVTT + +00:00:03.360 --> 00:00:05.600 +Te doy la bienvenida de nuevo. La clase + +00:00:05.600 --> 00:00:09.280 +pasada, lo que vimos fue cómo operar, vimos + +00:00:09.280 --> 00:00:13.325 +algebraicamente cómo operar entre escalares y vectores. En + +00:00:13.325 --> 00:00:16.765 +esta clase vamos a ver cómo se puede + +00:00:16.765 --> 00:00:19.404 +realizar esta operación en Python, vamos a comprobar + +00:00:19.404 --> 00:00:21.564 +algunas de las propiedades y, de igual manera, + +00:00:21.564 --> 00:00:26.445 +vamos a ver qué significa geométricamente, visualmente, operar + +00:00:26.445 --> 00:00:30.849 +escalares. Sin más, vamos a la computadora. Ahora, + +00:00:30.910 --> 00:00:33.649 +nosotros ya vimos en clases pasadas cómo introducir + +00:00:33.710 --> 00:00:37.949 +NumPy nos permite introducir también estos elementos llamados + +00:00:37.949 --> 00:00:41.230 +NumPyArray, y los NumPyArray ya vimos que se + +00:00:41.230 --> 00:00:45.395 +comportan un poco como vectores, como los vectores + +00:00:45.395 --> 00:00:48.115 +algebraicos que hemos venido manejando. La una de + +00:00:48.115 --> 00:00:50.115 +las ventajas muy grandes o de las más + +00:00:50.115 --> 00:00:53.475 +grandes de utilizar NumPy sobre utilizar listas es + +00:00:53.475 --> 00:00:57.400 +que para realizar la operación de producto por + +00:00:57.400 --> 00:01:01.400 +un escalar vector en Python, simplemente tendríamos que + +00:01:01.400 --> 00:01:05.319 +utilizar este operador. Ahora, vamos a ver qué + +00:01:05.319 --> 00:01:07.660 +pasa si nosotros en lugar de utilizar NumPy + +00:01:07.880 --> 00:01:11.445 +utilizamos una lista, ¿de acuerdo? Por ejemplo, si + +00:01:11.445 --> 00:01:14.244 +nosotros declaramos a un vector a igual a + +00:01:14.244 --> 00:01:18.965 +la lista uno coma dos coma tres, si + +00:01:18.965 --> 00:01:21.924 +yo lo multiplico No, más sencillo, uno uno + +00:01:21.924 --> 00:01:26.960 +uno. Si nosotros multiplicáramos esta lista por tres, + +00:01:27.740 --> 00:01:30.800 +debería de quedarnos el vector tres tres tres. + +00:01:31.020 --> 00:01:33.180 +Veamos qué es lo que pasa. A por + +00:01:33.180 --> 00:01:37.440 +tres nos da este vector gigante, ¿por qué? + +00:01:37.740 --> 00:01:40.220 +Bueno, lo que hace este operador con las + +00:01:40.220 --> 00:01:43.685 +listas es que esta lista la multiplica este + +00:01:43.685 --> 00:01:46.085 +número de veces, pero no la multiplica entrada + +00:01:46.085 --> 00:01:50.325 +por entrada, sino multiplica esa lista en una + +00:01:50.325 --> 00:01:53.625 +lista más grande y luego se concatena. Es + +00:01:53.685 --> 00:01:57.380 +decir, toma esta primer lista, la plasma aquí + +00:01:57.380 --> 00:01:59.880 +y cumple que esta se repita tres veces, + +00:01:59.939 --> 00:02:04.119 +una, dos y tres, y después las concatena. + +00:02:04.340 --> 00:02:06.659 +Hay una suma aquí entre listas y nos + +00:02:06.659 --> 00:02:12.564 +queda exactamente este vector, ¿vale? Ahora, nosotros no + +00:02:12.564 --> 00:02:15.204 +quisiéramos eso, quisiéramos que nos tocara tres tres + +00:02:15.204 --> 00:02:17.284 +tres en lugar de tener este gran vector, + +00:02:17.284 --> 00:02:19.224 +que es más como un stack de vectores. + +00:02:19.605 --> 00:02:21.284 +Vamos a ver cómo lo haríamos con un + +00:02:21.284 --> 00:02:27.980 +pay. Ahora, vamos a partir de este vector, + +00:02:27.980 --> 00:02:31.100 +del uno coma menos uno coma uno, y + +00:02:31.100 --> 00:02:33.660 +vamos a partir también del escalar a igual + +00:02:33.660 --> 00:02:36.140 +a tres punto uno. Vamos a realizar las + +00:02:36.140 --> 00:02:39.360 +operaciones x por AYA por x para comprobar + +00:02:39.605 --> 00:02:42.564 +que se cumple la conmutatividad. De igual manera, + +00:02:42.564 --> 00:02:46.245 +vamos a comprobar la distribución sobre la suma + +00:02:46.245 --> 00:02:48.724 +de escalares y la distribución sobre la suma + +00:02:48.724 --> 00:02:53.939 +de vectores. Entonces, primero empecemos importando numpy. Luego, + +00:02:53.939 --> 00:02:56.900 +aquí vamos a declarar nuestro vector x, como + +00:02:56.900 --> 00:02:59.700 +está acá arriba, y vamos a declarar también + +00:02:59.700 --> 00:03:06.019 +nuestro escalar a. Ahora, veamos, vamos a multiplicar + +00:03:06.019 --> 00:03:09.135 +a por x simplemente, y esto nos da + +00:03:09.515 --> 00:03:12.155 +exactamente lo que nosotros estaríamos buscando, que es + +00:03:12.155 --> 00:03:14.315 +multiplicar tres punto uno por uno, que nos + +00:03:14.315 --> 00:03:16.635 +da tres punto uno, tres punto uno por + +00:03:16.635 --> 00:03:18.555 +menos uno, que nos daría menos tres punto + +00:03:18.555 --> 00:03:20.235 +uno, y tres punto uno por uno otra + +00:03:20.235 --> 00:03:22.860 +vez, que nos daría tres punto uno. Es + +00:03:22.959 --> 00:03:25.959 +exactamente el resultado que tenemos aquí. Vamos a + +00:03:25.959 --> 00:03:28.680 +hacerlo ahora x por a, es decir, al + +00:03:28.680 --> 00:03:32.280 +revés. Aquí multiplicamos a por x, acabamos de + +00:03:32.280 --> 00:03:36.045 +multiplicar x por a, y nos da exactamente + +00:03:36.265 --> 00:03:38.985 +el mismo resultado. Eso quiere decir que la + +00:03:38.985 --> 00:03:43.145 +operación sí está conmutando, ya la comprobamos. Ahora, + +00:03:43.145 --> 00:03:46.105 +vamos a aclarar un nuevo escalar, ese nuevo + +00:03:46.105 --> 00:03:48.265 +escalar va a ser b igual a menos + +00:03:48.265 --> 00:03:52.450 +a. Entonces, si nosotros realizamos la suma de + +00:03:52.450 --> 00:03:54.530 +b más a, sabemos que nos debería de + +00:03:54.530 --> 00:03:57.090 +dar cero, y si eso lo multiplicamos por + +00:03:57.090 --> 00:03:59.750 +x, eso nos debería de dar el vector + +00:03:59.810 --> 00:04:04.415 +cero. Vamos a hacerlo. Y vemos que, efectivamente, + +00:04:04.474 --> 00:04:06.635 +el vector que se nos arroja es el + +00:04:06.635 --> 00:04:10.474 +vector cero. Recuerden que, como lo mencioné en + +00:04:10.474 --> 00:04:13.435 +clases pasadas, menos cero o cero para fines + +00:04:13.435 --> 00:04:15.870 +prácticos va a ser lo mismo para nosotros, + +00:04:15.870 --> 00:04:17.709 +y es que este menos viene de la + +00:04:17.709 --> 00:04:22.510 +representación que tenemos en Python. Ahora, como vimos + +00:04:22.510 --> 00:04:24.350 +una de las propiedades acá arriba en la + +00:04:24.350 --> 00:04:28.510 +distribución sobre los escalares, daría lo mismo sumarlos + +00:04:28.510 --> 00:04:32.565 +y después multiplicarlos, que primero multiplicarlo y después + +00:04:32.565 --> 00:04:34.745 +sumarlos. Vamos a ver que esto se cumpla. + +00:04:35.205 --> 00:04:38.565 +Entonces, aquí hicimos b más a por x. + +00:04:38.565 --> 00:04:39.925 +Lo que vamos a hacer aquí va a + +00:04:39.925 --> 00:04:42.425 +ser x por a más x por b, + +00:04:43.640 --> 00:04:47.000 +como lo tenemos aquí, y nos daremos cuenta + +00:04:47.000 --> 00:04:49.340 +que, en efecto, nos da el vector cero. + +00:04:49.720 --> 00:04:52.060 +Entonces, eso quiere decir que así se distribuye + +00:04:52.200 --> 00:04:54.380 +sobre la suma. Vamos a hacer un ejercicio + +00:04:55.000 --> 00:04:57.885 +más, pero vamos a considerar un dos vector. + +00:04:59.945 --> 00:05:06.605 +Consideremos el dos vector, veamos, el dos vector, + +00:05:07.770 --> 00:05:18.349 +vamos a llamarle b, igual al dos coma, + +00:05:18.569 --> 00:05:22.865 +al uno coma uno, por ejemplo. Sí, muy + +00:05:22.865 --> 00:05:28.165 +buen vector, excelente vector. Ahora, si nosotros consideramos + +00:05:30.225 --> 00:05:34.785 +un escalar a igual a menos uno, un + +00:05:34.785 --> 00:05:41.840 +escalar b igual a dos, y un escalar + +00:05:42.380 --> 00:05:46.620 +c igual a cero punto uno van a + +00:05:46.620 --> 00:05:50.240 +tener resultados totalmente distintos si nosotros lo multiplicamos + +00:05:50.460 --> 00:05:53.915 +por este vector. Pero ¿qué tan distintos? Bien, + +00:05:53.915 --> 00:05:56.655 +vamos a declarar primero esos vectores aquí abajo. + +00:05:57.195 --> 00:06:04.475 +Declaremos b igual a nuestro numpy array n + +00:06:04.475 --> 00:06:08.030 +p dot array, paréntesis, y declaramos como si + +00:06:08.030 --> 00:06:11.010 +fuera una lista uno coma uno. Ya declaramos + +00:06:11.070 --> 00:06:13.630 +nuestro vector, y de una vez declaremos también + +00:06:13.630 --> 00:06:17.169 +nuestros escalares, a igual a menos uno, b + +00:06:20.435 --> 00:06:26.355 +igual a dos, y c igual a cero + +00:06:26.355 --> 00:06:29.955 +punto uno. ¿Qué es lo que va a + +00:06:29.955 --> 00:06:34.300 +pasar si yo multiplico b por ABYC? Bueno, + +00:06:34.300 --> 00:06:39.660 +algebraicamente simplemente es esto, nos da menos uno + +00:06:39.660 --> 00:06:45.039 +y menos uno en las dos entradas. B + +00:06:45.259 --> 00:06:47.740 +por b nos da dos y dos en + +00:06:47.740 --> 00:06:56.905 +las entradas, YCB por c, una disculpa aquí + +00:06:56.905 --> 00:07:00.365 +para mí, cero punto uno cero punto uno. + +00:07:02.840 --> 00:07:07.159 +¿Qué significa esto geométricamente? Porque sí, los vectores + +00:07:07.159 --> 00:07:10.460 +tienen una interpretación geométrica, así que vamos ahí. + +00:07:10.919 --> 00:07:13.659 +Los invito a que visiten este sitio, Geogebra + +00:07:13.719 --> 00:07:17.715 +dot org calculator, y en este sitio nosotros + +00:07:17.715 --> 00:07:21.955 +vamos a poder acceder a poder ver vectores + +00:07:21.955 --> 00:07:24.515 +o dos vectores, es decir, vectores en el + +00:07:24.515 --> 00:07:26.455 +plano, a eso se le llama el plano. + +00:07:26.595 --> 00:07:29.949 +Vamos a aclarar nuestro vector inicial. Lo declaramos + +00:07:29.949 --> 00:07:33.750 +metiendo vector uno coma uno, y ahí está + +00:07:33.750 --> 00:07:37.130 +nuestro vector inicial, ¿lo podemos ver? Los vectores + +00:07:37.190 --> 00:07:39.849 +los podemos representar dentro del plano como flechas + +00:07:39.870 --> 00:07:42.470 +y tienen algo que se llama sentido, es + +00:07:42.470 --> 00:07:44.995 +decir, apuntan hacia un lado, tienen algo que + +00:07:44.995 --> 00:07:49.495 +se llama magnitud, que es exactamente esto. Ahora, + +00:07:50.275 --> 00:07:51.634 +¿qué es qué es lo que mide la + +00:07:51.634 --> 00:07:54.755 +flecha a la magnitud? Ahora, nosotros hace ratito + +00:07:54.755 --> 00:07:58.675 +multiplicándolo llegamos a dos resultados distintos. ¿Cuáles fueron + +00:07:58.675 --> 00:08:03.920 +esos resultados? Bueno, regresemos a nuestro notebook. Si + +00:08:03.920 --> 00:08:08.400 +nosotros lo multiplicábamos por menos uno, por a, + +00:08:08.400 --> 00:08:11.360 +lo que teníamos era este nuevo vector, el + +00:08:11.360 --> 00:08:13.375 +menos uno coma menos uno. ¿Cómo se ve + +00:08:13.375 --> 00:08:22.235 +ese vector? Bueno, ponemos vector menos uno coma + +00:08:22.235 --> 00:08:26.075 +menos uno. Fíjense que algo muy curioso es + +00:08:26.075 --> 00:08:28.820 +que, en lugar de que el sentido sea + +00:08:28.820 --> 00:08:32.919 +este, se cambia totalmente el sentido, es decir, + +00:08:33.299 --> 00:08:37.460 +multiplicar por un escalar negativo cambia el sentido + +00:08:37.460 --> 00:08:40.765 +del vector. Si nosotros lo multiplicáramos a este + +00:08:40.765 --> 00:08:43.245 +vector b, el menos uno menos uno, nuevamente + +00:08:43.245 --> 00:08:46.765 +por menos uno, nos daría al vector en + +00:08:46.765 --> 00:08:49.645 +esta dirección, es decir, nos regresaría el vector + +00:08:49.645 --> 00:08:54.385 +u, ¿vale? Vamos a desaparecer este vector. Ahora, + +00:08:55.150 --> 00:08:57.710 +¿qué pasa con el vector b? El vector + +00:08:57.710 --> 00:09:00.830 +b era el vector dos y nos daba + +00:09:00.830 --> 00:09:03.070 +el vector, no, el escalar dos, y nos + +00:09:03.070 --> 00:09:06.270 +daba el vector dos coma dos. Entonces, veamos + +00:09:06.270 --> 00:09:10.050 +cómo se ve ese. Vector dos coma dos. + +00:09:10.245 --> 00:09:15.305 +Fíjense que, en este caso, el vector b + +00:09:15.605 --> 00:09:18.565 +es dos veces la magnitud que tenía el + +00:09:18.565 --> 00:09:22.404 +vector u. Está en el mismo sentido, tiene + +00:09:22.404 --> 00:09:27.670 +la misma dirección, pero tiene una magnitud mucho + +00:09:27.670 --> 00:09:30.949 +mayor, tiene un tamaño mucho más grande, es + +00:09:30.949 --> 00:09:36.870 +decir, que multiplicarlo por un escalar positivo lo + +00:09:36.870 --> 00:09:41.945 +hace más grande. Regresando, multiplicarlo por un vector + +00:09:41.945 --> 00:09:44.825 +negativo le va a cambiar el sentido. Pero + +00:09:44.825 --> 00:09:47.865 +¿qué pasa ahora si nosotros, regresamos al vector + +00:09:47.865 --> 00:09:50.505 +que teníamos originalmente, el uno coma uno, si + +00:09:50.505 --> 00:09:53.885 +nosotros lo multiplicamos por este número de aquí, + +00:09:54.449 --> 00:09:58.529 +cero punto uno. Bueno, pues eso nos daba + +00:09:58.529 --> 00:10:00.930 +el vector cero punto uno coma cero punto + +00:10:00.930 --> 00:10:08.255 +uno. Vamos a declararlo aquí. Cero punto uno + +00:10:08.255 --> 00:10:12.415 +coma cero punto uno. ¿Qué es lo que + +00:10:12.415 --> 00:10:16.015 +pasó? Bueno, obtuvimos este vector, que es un + +00:10:16.015 --> 00:10:18.755 +vector súper pequeño. Fíjense que lo que hicimos + +00:10:18.895 --> 00:10:22.730 +fue encoger el vector original. Nuestro vector original + +00:10:22.950 --> 00:10:29.190 +es muchísimo más grande. Entonces, básicamente, lo que + +00:10:29.190 --> 00:10:32.390 +tenemos es que, si nosotros multiplicamos a nuestro + +00:10:32.390 --> 00:10:35.270 +vector por un número positivo, si el número + +00:10:35.270 --> 00:10:37.755 +es mayor que uno, entonces lo que nos + +00:10:37.755 --> 00:10:41.835 +va a causar es hacer la magnitud mucho + +00:10:41.835 --> 00:10:48.714 +más grande de nuestro vector, digamos, amplificar. Si + +00:10:48.714 --> 00:10:52.150 +nuestro escalar es menor que uno, pero sigue + +00:10:52.150 --> 00:10:57.830 +siendo positivo, lo que va a hacer es + +00:10:57.830 --> 00:11:01.290 +hacerlo más pequeño, podríamos decir encogerlo o comprimirlo. + +00:11:02.150 --> 00:11:07.165 +Lo vemos acá. Y si nuestro vector es + +00:11:07.165 --> 00:11:10.285 +menor que cero, es decir, negativo, lo que + +00:11:10.285 --> 00:11:14.845 +hace es que le cambia la dirección, le + +00:11:14.845 --> 00:11:19.779 +cambia el sentido. Ahora bien, ¿qué pasa si + +00:11:19.779 --> 00:11:23.160 +nosotros lo multiplicamos, pero que sea un vector + +00:11:24.260 --> 00:11:28.200 +menor que menos uno, pero que sea negativo? + +00:11:31.384 --> 00:11:33.865 +Es decir, mayor que menos uno, menor que + +00:11:33.865 --> 00:11:37.384 +cero. Por ejemplo, consideramos que lo multiplicamos por + +00:11:37.384 --> 00:11:39.625 +menos cero punto uno, esto nos daría el + +00:11:39.625 --> 00:11:42.185 +vector menos cero punto uno menos cero punto + +00:11:42.185 --> 00:11:45.464 +uno. Vamos a ver cómo se ve este + +00:11:45.464 --> 00:11:49.840 +vector. Y fíjense que si tenemos este vector + +00:11:49.840 --> 00:11:53.220 +original o ese vector original lo multiplicado por + +00:11:53.760 --> 00:11:58.420 +el menos cero punto uno, nos da exactamente + +00:11:58.560 --> 00:12:01.435 +lo mismo que en el caso positivo, simplemente + +00:12:01.575 --> 00:12:05.895 +se encogió nuestro vector, miren. Partimos de nuestro + +00:12:05.895 --> 00:12:11.895 +vector u, lo multiplicamos por menos uno y + +00:12:11.895 --> 00:12:15.095 +nos da este vector encogido a, pero en + +00:12:15.095 --> 00:12:18.990 +sentido contrario. Esta es la noción que tenemos + +00:12:18.990 --> 00:12:23.170 +que tener geométricamente cuando operamos escalares con vectores. + +00:12:23.630 --> 00:12:27.709 +Los vectores van a sufrir una magnificación, es + +00:12:27.709 --> 00:12:32.145 +decir, se van a hacer más grandes, su + +00:12:32.145 --> 00:12:35.445 +magnitud va a cambiar, van a también hacerse + +00:12:36.305 --> 00:12:40.545 +más pequeños si los multiplicamos por escalares entre + +00:12:40.545 --> 00:12:43.905 +menos uno y uno. Si son negativos, hay + +00:12:43.905 --> 00:12:47.050 +que recordar que se van a hacer, se + +00:12:47.050 --> 00:12:50.089 +va a cambiar el sentido y, además, si + +00:12:50.089 --> 00:12:52.250 +es negativo y es mayor que uno, cambia + +00:12:52.250 --> 00:12:55.610 +el sentido y lo magnifica, pero en el + +00:12:55.610 --> 00:12:58.889 +sentido contrario. Es decir, si lo multiplicáramos por + +00:12:58.889 --> 00:13:04.065 +menos dos, en lugar de dos, este vector + +00:13:04.605 --> 00:13:07.645 +w ya no apuntaría hacia acá, sino apuntaría + +00:13:07.645 --> 00:13:11.345 +en la dirección opuesta. Por ejemplo, menos dos, + +00:13:14.940 --> 00:13:20.700 +menos dos y menos dos. Entonces, ese era + +00:13:20.700 --> 00:13:23.980 +nuestro vector original y la magnitud de esta + +00:13:23.980 --> 00:13:26.634 +es del doble, pero ahora está en la + +00:13:26.634 --> 00:13:32.654 +dirección opuesta. Apunta en la dirección opuesta. Perfecto, + +00:13:32.954 --> 00:13:36.254 +regresemos a nuestro notebook. Para terminar esta clase, + +00:13:36.714 --> 00:13:41.610 +me gustaría que realizaras esos ejercicios. Primero, escribe + +00:13:41.610 --> 00:13:44.550 +todos los vectores unitarios estándar de r cuatro. + +00:13:45.090 --> 00:13:51.010 +Nosotros acá dijimos que un espacio vectorial de + +00:13:51.010 --> 00:13:55.670 +dimensión n tenía hasta n vectores unitarios estándar. + +00:13:56.335 --> 00:13:58.654 +Tú vas a tener que construirlos para un + +00:13:58.654 --> 00:14:01.935 +espacio de dimensión cuatro. El gint es que + +00:14:01.935 --> 00:14:04.495 +son cuatro y, además, te puedes basar en + +00:14:04.495 --> 00:14:07.375 +la construcción que ya habíamos hecho para los + +00:14:07.375 --> 00:14:10.195 +de r tres, que son estos de aquí. + +00:14:13.860 --> 00:14:18.040 +Ahora bien, escribe tres combinaciones lineales también de + +00:14:18.100 --> 00:14:20.420 +vectores, ahora en r tres, no en r + +00:14:20.420 --> 00:14:23.380 +cuatro, para poder expresar al vector uno coma + +00:14:23.380 --> 00:14:27.555 +uno coma uno. Si recordamos, acá vimos una + +00:14:27.555 --> 00:14:31.714 +combinación para poder expresar a este vector en + +00:14:31.714 --> 00:14:34.935 +término de los vectores unitarios, pero la combinación + +00:14:35.235 --> 00:14:37.795 +lineal no necesariamente tiene que ser en término + +00:14:37.795 --> 00:14:41.210 +de los vectores unitarios. Una, la más sencilla, + +00:14:41.210 --> 00:14:43.690 +sería en función de las de los vectores + +00:14:43.690 --> 00:14:48.570 +unitarios. Pero el reto aquí es que escribas + +00:14:48.570 --> 00:14:54.005 +tres combinaciones. Por último, uno de los problemas + +00:14:54.144 --> 00:14:58.404 +será que escribas tres combinaciones afines con vectores + +00:14:58.545 --> 00:15:01.105 +de r tres, donde b cero, b uno + +00:15:01.105 --> 00:15:04.545 +y b dos sean distintos, pero que se + +00:15:04.545 --> 00:15:07.010 +cumpla que la suma de ellos, b cero + +00:15:07.010 --> 00:15:09.090 +más b uno más b dos sea igual + +00:15:09.090 --> 00:15:11.410 +a uno. Un hind será que si no + +00:15:11.410 --> 00:15:14.530 +se te ocurre ninguna combinación de coeficientes que + +00:15:14.530 --> 00:15:17.970 +te dé un uno, esta ecuación realmente tiene + +00:15:17.970 --> 00:15:21.735 +infinitas soluciones, y una forma de poder acceder + +00:15:21.735 --> 00:15:23.895 +a ellas es a través de un programa, + +00:15:23.895 --> 00:15:26.135 +es que hagas un programa. Voy a hacer + +00:15:26.135 --> 00:15:29.735 +un ejemplo en r dos, o bueno, buscando + +00:15:29.735 --> 00:15:32.455 +nada más resolverla para b cero más b + +00:15:32.455 --> 00:15:36.920 +uno igual a uno. El agente que te + +00:15:36.920 --> 00:15:39.800 +voy a dar es utilizar esta función, se + +00:15:39.800 --> 00:15:44.680 +llama n p linkspace. Nosotros le damos un + +00:15:44.680 --> 00:15:49.365 +punto de partida, un punto final, y además + +00:15:49.365 --> 00:15:53.524 +le decimos cuántos elementos queremos. Lo que va + +00:15:53.524 --> 00:15:56.264 +a hacer va a ser partir la distancia + +00:15:57.204 --> 00:15:59.445 +entre el cero y el cinco en mil + +00:15:59.445 --> 00:16:02.567 +cachos, en donde el cacho cero y el + +00:16:02.567 --> 00:16:05.081 +cacho uno van a estar separados a la + +00:16:05.081 --> 00:16:08.290 +misma distancia. Veamos los elementos. Si nosotros ejecutamos + +00:16:08.430 --> 00:16:12.510 +esta instrucción, veamos que nos arroja mil elementos, + +00:16:12.510 --> 00:16:15.334 +un vector con mil elementos, y que son + +00:16:15.475 --> 00:16:20.274 +exactamente los números del cero al cinco. Si + +00:16:20.274 --> 00:16:24.935 +nosotros le calculamos su longitud, nos daremos cuenta + +00:16:25.394 --> 00:16:28.980 +que la longitud es exactamente mil. Ahora, voy + +00:16:28.980 --> 00:16:32.340 +a asignar este vector a una variable, digamos + +00:16:32.340 --> 00:16:37.560 +a. Notemos que este vector cumple que a + +00:16:38.420 --> 00:16:43.214 +cero, que es la primera entrada, restada de + +00:16:43.214 --> 00:16:49.135 +la entrada a uno, es simplemente cero punto + +00:16:49.135 --> 00:16:52.195 +cero cinco. Veamos qué pasa con la entrada + +00:16:52.255 --> 00:17:02.110 +siguiente. A la entrada tres menos la entrada + +00:17:02.410 --> 00:17:07.369 +dos. Nos da exactamente el mismo número, es + +00:17:07.369 --> 00:17:11.205 +decir, todos los elementos de esta de este + +00:17:11.585 --> 00:17:15.765 +vector cumplen que están separados o distan exactamente + +00:17:16.305 --> 00:17:19.105 +este número, ¿vale? Y lo mismo lo podemos + +00:17:19.105 --> 00:17:21.744 +hacer con los dos últimos. Sabemos que la + +00:17:21.744 --> 00:17:25.150 +longitud del vector es mil, entonces, como el + +00:17:25.150 --> 00:17:28.430 +índice va desde cero hasta n menos uno, + +00:17:28.430 --> 00:17:31.390 +nuestros índices irían de cero hasta novecientos noventa + +00:17:31.390 --> 00:17:36.050 +y nueve. Entonces, a novecientos noventa y nueve + +00:17:38.975 --> 00:17:42.674 +menos el novecientos noventa y ocho, nos da + +00:17:43.054 --> 00:17:46.095 +casi el mismo número. Estas variaciones tan pequeñas + +00:17:46.095 --> 00:17:48.735 +son normales, pero si nos fijamos en los + +00:17:48.735 --> 00:17:52.540 +tres primeros dígitos como dígitos significativos, es exactamente + +00:17:52.919 --> 00:17:55.400 +la misma diferencia. Y es que, a veces, + +00:17:55.400 --> 00:17:57.880 +por la precisión, no se puede partir todos + +00:17:57.880 --> 00:18:01.880 +los cachos a esta precisión en el mismo + +00:18:01.880 --> 00:18:07.020 +tamaño. Sin embargo, son considerablemente iguales los cachos. + +00:18:09.105 --> 00:18:12.065 +Y una cosa más, si nosotros llamamos al + +00:18:12.065 --> 00:18:14.645 +a cero, este debería de ser el cero, + +00:18:14.705 --> 00:18:18.465 +y si nosotros llamamos al a novecientos noventa + +00:18:18.465 --> 00:18:21.365 +y nueve, este debería ser el cinco exactamente. + +00:18:23.520 --> 00:18:29.120 +Entonces, tu reto será utilizar esta función para + +00:18:29.120 --> 00:18:33.760 +poder encontrar una solución a esta ecuación. Eso + +00:18:33.760 --> 00:18:35.679 +es todo por mi parte. Nos vemos en + +00:18:35.679 --> 00:18:36.740 +la próxima clase. diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Resumen.html" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Resumen.html" new file mode 100644 index 0000000000000000000000000000000000000000..1a2e4ad534c03950c7427aedf82f3944af00be4d --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-Resumen.html" @@ -0,0 +1,164 @@ + + + + + + + Operaciones con Escalares y Vectores en Python usando NumPy + + + +
+
+

Resumen

¿Cómo usar NumPy para operaciones entre escalares y vectores en Python?

+

Las matemáticas y la programación pueden parecer mundos distintos, pero gracias a herramientas como NumPy, se unen para simplificar nuestras vidas. Trabajar con operaciones entre escalares y vectores en Python es una tarea sencilla y eficiente, especialmente cuando se compara con listas nativas del lenguaje. NumPy no solo facilita estas operaciones, sino que también abre un camino hacia la visualización y comprensión geométrica de los vectores.

+

¿Qué ventajas tienen los NumPyArrays sobre las listas en Python?

+

Los NumPyArrays ofrecen una serie de beneficios sobre las listas nativas de Python, una de las cuales es la eficiencia en el manejo de operaciones matemáticas:

+
    +
  • +

    Producto escalar-vector: Con NumPy, multiplicar un escalar por un vector se realiza directamente utilizando el operador *. Esto es algo que, con listas, podría causar confusión dado que se replicaría la lista concatenando su contenido.

    +
    import numpy as np
+
+# Definimos un vector usando NumPy
+x = np.array([1, -1, 1])
+a = 3.1
+
+# Realizamos la multiplicación entre escalar y vector
+resultado = a * x
+print(resultado)  # Output: [ 3.1 -3.1  3.1 ]
+
    +
    • +
+

¿Cómo se verifica la conmutatividad y otras propiedades en Python?

+

La conmutatividad y la distribución sobre suma de escalares y vectores son fundamentales en álgebra:

+
    +
  • +

    Conmutatividad del producto escalar: Multiplicar un escalar por un vector en cualquier orden debe dar el mismo resultado.

    +
    # Comprobación de la conmutatividad
+resultado1 = a * x
+resultado2 = x * a
+print(resultado1 == resultado2)  # Output: True
+
    +
    • +
  • +

    Distribución sobre la suma de escalares: Se puede sumar dos escalares y luego multiplicar el resultado por un vector, o multiplicar cada uno de los escalares por el vector por separado y luego sumarlos.

    +
    b = -a
+vector_cero = (b + a) * x
+print(vector_cero)  # Output: [0. 0. 0.]
+
+resultado_dist1 = a * x + b * x
+print(resultado_dist1 == vector_cero)  # Output: True
+
    +
    • +
+

¿Qué significado geométrico tiene multiplicar escalares por vectores?

+

Los vectores tienen una interpretación geométrica que cobra vida en el plano cartesiano. Al multiplicar un escalar a un vector, observamos cambios en magnitud y sentido:

+
    +
  • Multiplicación por un escalar positivo: +
      +
    • Si el escalar es mayor que uno, el vector se magnifica, es decir, aumenta su tamaño.
      • +
    • Si el escalar está entre cero y uno, el vector se encoge.
      • +
    +
    • +
  • Multiplicación por un escalar negativo: +
      +
    • Cambia la dirección del vector.
      • +
    • Si es menor que menos uno, también magnifica el vector en la dirección opuesta.
      • +
    +
    • +
+

El uso de herramientas como Geogebra facilita la visualización de estos conceptos, permitiendo representar vectores como flechas en un plano, donde su magnitud y dirección son obvias al ojo.

+

¿Qué ejercicios prácticos puedes realizar para dominar estos conceptos?

+

El mejor camino hacia el aprendizaje es la práctica:

+
    +
  1. Vectores unitarios en R4: Escribe los vectores unitarios estándar en un espacio de cuatro dimensiones.
    2. +
  2. Combinaciones lineales en R3: Encuentra tres combinaciones lineales distintas para expresar el vector ((1, 1, 1)).
    3. +
  3. Combinaciones afines en R3: Crea combinaciones afines donde los coeficientes sumen a uno.
    4. +
+
# Ejemplo básico de uso de np.linspace para encontrar soluciones a ecuaciones lineales
+a = np.linspace(0, 5, 1000)
+print(a)
+
+

Con estos ejercicios, ganarás comprensión y destreza en el manejo de operaciones algebraicas con NumPy, y la aplicación geométrica y práctica de vectores. ¡Continúa explorando y aprendiendo para dominar cada vez más estos poderosos conceptos!

+
+
+ + \ No newline at end of file diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-producto_escalar_ca62b4c4-85e7-449a-8a01-424da3f688a7.ipynb" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-producto_escalar_ca62b4c4-85e7-449a-8a01-424da3f688a7.ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..9d2662b51f6a4d527352e2d77716032a8fbf3dcf --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/07-producto_escalar_ca62b4c4-85e7-449a-8a01-424da3f688a7.ipynb" @@ -0,0 +1,472 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. Producto por un escalar o multiplicación escalar-vector." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Otra operación es el *producto por un escalar* o *multiplicación escalar-vector* en la cual un vector es multiplicado por un escalar. La operación se hace elemento a elemento. Sea $\\vec{v}$ un vector de $\\mathbb{R}^{n}$ y $\\alpha \\in \\mathbb{R}$. Si $\\vec{x} = \\alpha \\vec{v}$ entonces:\n", + "$$\n", + "\\vec{x} = \\alpha \\vec{v} = \\alpha\\begin{bmatrix}v_{0}\\\\ v_{1}\\\\ \\vdots \\\\ v_{n-1}\\end{bmatrix} = \\begin{bmatrix}\\alpha \\cdot v_{0}\\\\ \\alpha \\cdot v_{1}\\\\ \\vdots \\\\ \\alpha \\cdot v_{n-1}\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Por ejemplo, si $\\vec{v} = (0,1,-2.3)$ y $\\alpha = -1.1$ entonces $\\alpha \\vec{v} = (0,-1.1,2.53)$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.1 Propiedades del producto por un escalar-vector" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sean $\\vec{x},\\vec{y}$ dos vectores y $\\alpha, \\beta$ dos escalares cualquiera. Las propiedades que cumple el producto escalar-vector son las siguientes:\n", + "* Conmutatividad: $\\alpha \\vec{x} = \\vec{x}\\alpha $\n", + "\n", + "* Asociatividad: $(\\beta \\alpha)\\vec{x} = \\beta (\\alpha\\vec{x})$\n", + "\n", + "* Distribución sobre suma escalar: $(\\alpha + \\beta)\\vec{x} = \\alpha \\vec{x} + \\beta\\vec{x} =\\beta\\vec{x} + \\alpha\\vec{x} = \\vec{x}(\\alpha + \\beta) $\n", + "\n", + "* Distribución sobre suma de vectores: $\\alpha (\\vec{x}+\\vec{y}) = \\alpha\\vec{x} + \\alpha\\vec{y}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.2 Algunas consideraciones" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Combinaciones lineales**. Sean $\\vec{a}_{0},\\vec{a}_{1},\\dots,\\vec{a}_{m-1}$ $n$-vectores y $\\beta_{0},\\beta_{1},\\dots,\\beta_{m-1}$ escalares entonces podemos definir el siguiente $n$-vector:\n", + "\n", + "$$\n", + "\\beta_{0}\\vec{a}_{0}+\\beta_{1}\\vec{a}_{1}+\\cdots+\\beta_{m-1}\\vec{a}_{m-1}\n", + "$$\n", + "\n", + "Es llamado una *combinación lineal* de los vectores $\\vec{a}_{0},\\vec{a}_{1},\\dots,\\vec{a}_{m-1}$. Los escalares $\\beta_{0},\\beta_{1},\\dots,\\beta_{m-1}$ son llamados los *coeficientes* de la combinación lineal." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Combinaciones lineales de vectores unitarios**. Es posible escribir cualquier $\\vec{b}$ $n$-vector como combinación lineal de los vectores unitarios estándar:\n", + "\n", + "$$\n", + "\\vec{b} = b_{0}\\hat{e}_{0}+b_{1}\\hat{e}_{1} + \\cdots +b_{n-1}\\hat{e}_{n-1}\n", + "$$\n", + "\n", + "Con $b_{i}$ escalares y $\\hat{e}_{i}$ el i-ésimo vector unitario. Un ejemplo específico sería:\n", + "\n", + "$$\n", + "\\begin{bmatrix}1\\\\ -1\\\\ 0\\end{bmatrix} = (1)\\begin{bmatrix}1\\\\ 0\\\\ 0\\end{bmatrix} + (-1)\\begin{bmatrix}0\\\\ 1\\\\ 0\\end{bmatrix} + (0)\\begin{bmatrix}0\\\\ 0\\\\ 1\\end{bmatrix}\n", + "$$\n", + "\n", + "Como nota final aquí, notemos que si el espacio vectorial es de dimensión $n$ entonces tiene $n$ vectores unitarios $\\hat{e}_{i}$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Combinaciones lineales especiales**. Algunas combinaciones de $n$-vectores $\\vec{a}_{0},\\vec{a}_{1},\\dots,\\vec{a}_{m-1}$ tienen nombres especiales. Por ejemplo, si los coeficientes de la combinación lineal son tales que $\\beta_{0}=\\beta_{1}=\\cdots=\\beta_{m-1} = 1$ entonces simplemente es una suma de vectores. Si en cambio $\\beta_{0}=\\beta_{1}=\\cdots=\\beta_{m-1} = 1/m$ entonces la combinación lineal se llama el *promedio de vectores*. \n", + "Cuando $\\beta_{0}+\\beta_{1}+\\cdots+\\beta_{m-1}=1$ entonces la combinación lineal se llama *combinación afín*, cuando los coeficientes $\\beta_{i}$ son no-negativos entonces la combinación lineal es llamada una *mezcla*, *combinación convexa* o un *promedio pesado*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.3 Producto por un escalar-vector en Python" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Desde la clase pasada introducimos Numpy para manejo de vectores. Una de las fortunas de usar numpy sobre listas es la simpleta de este tipo de operaciones. Realizar esta operación será tan sencillo como usar el operador $*$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Partamos del vector $\\vec{x}= (1,-1,1)$ y del escalar $a = 3.1$ entonces, realicemos las operaciones $a\\vec{x}$ y $\\vec{x}a$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np #primero importamos numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.array([1,-1,1]) #declaramos el vector x\n", + "\n", + "a = 3.1 #declaramos el escalar a" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ax es [ 3.1 -3.1 3.1]\n" + ] + } + ], + "source": [ + "print('ax es',a*x)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xa es [ 3.1 -3.1 3.1]\n" + ] + } + ], + "source": [ + "print('xa es',x*a)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "b = -a" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(b+a)x es [ 0. -0. 0.]\n" + ] + } + ], + "source": [ + "print('(b+a)x es',(b+a)*x)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xa+xb es [0. 0. 0.]\n" + ] + } + ], + "source": [ + "print('xa+xb es',b*x+ x*a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora un ejecio más $\\vec{v} = (1,1)$. Si consideramos a = -1, b = 2, c = 0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "v = np.array([1,1])\n", + "a = -1\n", + "b = 2\n", + "c = 0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-1, -1])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v*a" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 2])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v*b" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.1, 0.1])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v*c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3.3 Ejercicios" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 1**. Escribe TODOS los vectores unitarios estándar de $\\mathbb{R}^{4}$. *Hint:* son cuatro. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 2**. Escribe tres combinaciones lineales de vectores en $\\mathbb{R}^{3}$ para expresar el vector $[1,1,1]$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 3.** Escribe tres combinaciones afines con vectores de $\\mathbb{R}^{3}$ donde $\\beta_{0}\\neq\\beta_{1}\\neq\\beta_{2}$ pero que se cumpla que $\\beta_{0}+\\beta_{1}+\\beta_{2}=1$. *HINT*: Si no se te ocurre ninguna combinación para los coeficientes la ecuación $\\beta_{0}+\\beta_{1}+\\beta_{2}=1$ tiene infinitas soluciones, puedes hacer un programa para encontrar tres. " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.linspace(0,5,1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.005005005005005005" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[1]-a[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.005005005005005005" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2]-a[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.005005005005005003" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[999]-a[998]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.0" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[999]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Lecturas recomendadas.txt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Lecturas recomendadas.txt" new file mode 100644 index 0000000000000000000000000000000000000000..2760ca86f92c5f7fdb9d136373b98526474eb71c --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Lecturas recomendadas.txt" @@ -0,0 +1 @@ +https://colab.research.google.com/drive/1zLgEfmILRmfGXpHHsH5e6gYc9kM7qT5S?usp=sharing diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Producto Interno de Vectores Definici\303\263n y Propiedades.mp4" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Producto Interno de Vectores Definici\303\263n y Propiedades.mp4" new file mode 100644 index 0000000000000000000000000000000000000000..8187df8989078e7c91aaf54c9fac50cafc6010d6 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Producto Interno de Vectores Definici\303\263n y Propiedades.mp4" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd4581b5df4a5a13cb4ebd082774ab547bc2005fae5c247e23706365a9f94d81 +size 121998230 diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Producto Interno de Vectores Definici\303\263n y Propiedades.vtt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Producto Interno de Vectores Definici\303\263n y Propiedades.vtt" new file mode 100644 index 0000000000000000000000000000000000000000..b87868ab03d3296dbb8e1bb2899d9621a4d21bb6 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Producto Interno de Vectores Definici\303\263n y Propiedades.vtt" @@ -0,0 +1,712 @@ +WEBVTT + +00:00:03.439 --> 00:00:05.359 +Te doy la bienvenida de nuevo. Esta es + +00:00:05.359 --> 00:00:08.100 +la clase de producto interno. El producto interno + +00:00:08.160 --> 00:00:12.340 +es una operación especial entre vectores. Ya vimos + +00:00:12.639 --> 00:00:15.219 +operaciones entre vectores, como la suma de vectores, + +00:00:15.315 --> 00:00:18.195 +y también ya vimos operaciones entre escalares y + +00:00:18.195 --> 00:00:20.435 +vectores, el producto escalar y vector. Lo vimos + +00:00:20.435 --> 00:00:22.994 +la clase pasada. Te invito a que si + +00:00:22.994 --> 00:00:26.355 +has tenido algún problema o has tenido dudas + +00:00:26.355 --> 00:00:28.733 +respecto al contenido que hemos visto, lo dejes + +00:00:28.733 --> 00:00:31.080 +en los comentarios y tanto la comunidad de + +00:00:31.080 --> 00:00:33.320 +Platzi como yo estaremos al pendiente para poder + +00:00:33.320 --> 00:00:37.480 +responderte tus dudas. Ahora, sin más, te voy + +00:00:37.480 --> 00:00:40.520 +a presentar esta nueva operación. Vamos a la + +00:00:40.520 --> 00:00:44.585 +computadora. Este es el notebook de producto interno + +00:00:44.585 --> 00:00:46.985 +y, como siempre, no te preocupes, este notebook + +00:00:46.985 --> 00:00:48.505 +va a estar disponible para que tú lo + +00:00:48.505 --> 00:00:52.825 +consultes. Ahora bien, a este le llamamos producto + +00:00:52.825 --> 00:00:56.265 +interno o producto interno estándar, o simplemente producto + +00:00:56.265 --> 00:00:59.410 +punto, a la operación entre dos n vectores, + +00:00:59.630 --> 00:01:01.550 +recuerden que tienen que ser los dos n + +00:01:01.550 --> 00:01:04.430 +vectores, y que vamos a definir como el + +00:01:04.430 --> 00:01:07.310 +siguiente escalar. La notación para el producto punto + +00:01:07.310 --> 00:01:11.305 +pueden ser esta clase de corchetes o simplemente + +00:01:11.305 --> 00:01:14.985 +un punto en medio, y se define como + +00:01:14.985 --> 00:01:17.965 +la suma de la multiplicación de sus entradas + +00:01:18.505 --> 00:01:22.345 +entrada por entrada. Es decir, el producto punto + +00:01:22.345 --> 00:01:25.990 +o el producto interno entre AYB es a + +00:01:25.990 --> 00:01:28.710 +cero por b cero más a uno por + +00:01:28.710 --> 00:01:30.890 +b uno más a dos por b dos + +00:01:31.110 --> 00:01:33.270 +más a tres por b tres más an + +00:01:33.270 --> 00:01:37.825 +por b n. Esto se denota matemáticamente como + +00:01:37.825 --> 00:01:41.104 +la suma desde I igual a cero hasta + +00:01:41.104 --> 00:01:43.665 +n menos uno de a I por b + +00:01:43.665 --> 00:01:47.765 +I. Simplemente, lo que esto denota es que + +00:01:47.825 --> 00:01:50.865 +este índice, el I, va a correr desde + +00:01:50.865 --> 00:01:54.180 +cero hasta n menos uno, porque son n + +00:01:54.180 --> 00:01:57.000 +vectores, y además que vas a multiplicar a + +00:01:57.000 --> 00:02:00.759 +los elementos AYB, los AIY los b I, + +00:02:00.979 --> 00:02:03.940 +que de ese índice los vas a sumar + +00:02:03.940 --> 00:02:06.180 +hasta el n menos uno, es decir, toda + +00:02:06.180 --> 00:02:09.394 +esta operación de aquí la podemos comprimir en + +00:02:09.394 --> 00:02:15.315 +este simple anotación de aquí. Por ejemplo, si + +00:02:15.315 --> 00:02:17.474 +a es igual al vector uno coma dos + +00:02:17.474 --> 00:02:19.635 +coma tres y b es igual al vector + +00:02:19.635 --> 00:02:22.530 +cuatro coma cinco coma seis, entonces, tendemos que + +00:02:22.530 --> 00:02:27.330 +el producto punto será simplemente a punto b, + +00:02:27.330 --> 00:02:30.770 +uno coma dos coma tres punto cuatro coma + +00:02:30.770 --> 00:02:33.510 +cinco coma seis igual a uno por cuatro, + +00:02:33.810 --> 00:02:38.485 +uno por cuatro, dos por cinco, más dos + +00:02:38.485 --> 00:02:41.444 +por cinco, más tres por seis, más tres + +00:02:41.444 --> 00:02:44.405 +por seis. Y esto nos da aquí, esto + +00:02:44.405 --> 00:02:47.525 +de aquí son cuatro, esto de aquí nos + +00:02:47.525 --> 00:02:51.100 +da un diez, y esto de aquí nos + +00:02:51.100 --> 00:02:55.340 +da un dieciocho, y eso es simplemente treinta + +00:02:55.340 --> 00:02:58.540 +y dos. Entonces, el producto punto de a + +00:02:58.540 --> 00:03:01.280 +por b nos da treinta y dos. Notemos + +00:03:01.420 --> 00:03:04.625 +otra vez y esto es muy importante. Otras + +00:03:05.005 --> 00:03:07.505 +operaciones entre vectores que habíamos visto, la suma, + +00:03:07.725 --> 00:03:10.045 +nos daba un n vector, si sumábamos dos + +00:03:10.045 --> 00:03:12.605 +n vectores, nos daba un n vector. En + +00:03:12.605 --> 00:03:15.165 +el caso del producto de escalar vector, también + +00:03:15.165 --> 00:03:17.565 +nos daba un n vector, multiplicar un escalar + +00:03:17.565 --> 00:03:20.069 +por un n vector nos daba un n + +00:03:20.069 --> 00:03:23.670 +vector. En este caso, el producto punto de + +00:03:23.670 --> 00:03:26.069 +dos n vectores nos va a dar un + +00:03:26.069 --> 00:03:28.310 +número, nos va a dar un escalar. Es + +00:03:28.310 --> 00:03:30.230 +por eso que a esto se le refiere + +00:03:30.230 --> 00:03:35.205 +también como el producto escalar. Bien, hasta este + +00:03:35.205 --> 00:03:38.085 +momento tenemos que, a este momento tenemos que + +00:03:38.085 --> 00:03:41.465 +hacer una nueva definición o una nueva revisión + +00:03:41.525 --> 00:03:45.060 +de notación. Y es que para nosotros jugar + +00:03:45.060 --> 00:03:47.620 +o hablar de vectores columna, es decir, vectores + +00:03:47.620 --> 00:03:50.260 +en esta representación, o vectores en la forma + +00:03:50.260 --> 00:03:52.740 +de un renglón, como esta representación de aquí, + +00:03:52.740 --> 00:03:55.540 +era lo mismo. A partir de este momento, + +00:03:55.540 --> 00:03:57.585 +vamos a definir el estándar de un vector + +00:03:57.665 --> 00:04:00.625 +como un vector columna, es decir, siempre que + +00:04:00.625 --> 00:04:03.025 +nos refiramos a un n vector a, hay + +00:04:03.025 --> 00:04:05.445 +que pensar al vector en forma de columna. + +00:04:07.425 --> 00:04:09.825 +Y esto nos va a permitir hablar de + +00:04:09.825 --> 00:04:13.550 +la operación de transposición. Una cosa muy importante + +00:04:13.550 --> 00:04:15.090 +es que antes de hablar de la transposición, + +00:04:15.709 --> 00:04:17.709 +va a dar lo mismo si nosotros le + +00:04:17.709 --> 00:04:22.930 +ponemos paréntesis cuadrados, paréntesis normales o corchetes. Estaremos + +00:04:22.990 --> 00:04:27.074 +hablando siempre de vectores columna. La forma de + +00:04:27.074 --> 00:04:29.074 +los paréntesis, de lo que nos delimite la + +00:04:29.074 --> 00:04:31.715 +lista, no nos va a cambiar para nada + +00:04:31.715 --> 00:04:34.275 +de qué tipo de elemento estemos hablando. Ahora + +00:04:34.275 --> 00:04:37.715 +bien, regresando a la transposición, tomemos el vector + +00:04:37.715 --> 00:04:39.715 +a, es decir, este vector que tenemos aquí + +00:04:39.715 --> 00:04:42.620 +arriba, y el vector transpuesto o la transposición + +00:04:42.920 --> 00:04:45.240 +del vector a lo vamos a denotar como + +00:04:45.240 --> 00:04:49.080 +a con este índice arriba t, este es + +00:04:49.080 --> 00:04:52.280 +súper índice. Y esto se lee como a + +00:04:52.280 --> 00:04:55.025 +transpuesto, y a transpuesto se ve como viene + +00:04:55.025 --> 00:04:58.085 +aquí. A transpuesto es igual a este vector, + +00:04:58.465 --> 00:05:00.625 +con la t arriba también, porque estamos indicando + +00:05:00.625 --> 00:05:04.164 +la la operación de transposición, y esto es + +00:05:04.305 --> 00:05:08.350 +simplemente el vector renglón. Es decir, transponer un + +00:05:08.350 --> 00:05:11.970 +vector columna nos da un vector renglón, ¿vale? + +00:05:12.510 --> 00:05:14.350 +Y hay algo muy interesante, y es que + +00:05:14.350 --> 00:05:16.669 +la transposición de la transposición nos da el + +00:05:16.669 --> 00:05:19.970 +vector original. Esto lo podemos obtener de nuevo. + +00:05:20.375 --> 00:05:23.675 +A traspuesta traspuesta es igual a a traspuesta + +00:05:24.055 --> 00:05:28.215 +traspuesta, que es igual a este renglón, sabemos + +00:05:28.215 --> 00:05:31.115 +que lo de aquí adentro es este renglón, + +00:05:31.895 --> 00:05:34.710 +y si nosotros transponemos este renglón, lo que + +00:05:34.710 --> 00:05:36.570 +nos va a dar es un vector columna, + +00:05:36.870 --> 00:05:39.510 +es decir, transponer un renglón nos da una + +00:05:39.510 --> 00:05:41.750 +columna y, trasponer una columna, nos da un + +00:05:41.750 --> 00:05:45.750 +renglón. Notemos que en esta operación no modificamos + +00:05:45.750 --> 00:05:48.884 +para nada a los elementos de a, simplemente + +00:05:48.944 --> 00:05:52.324 +se va a modificar, por una forma simplificada + +00:05:52.384 --> 00:05:55.985 +de decirlo, su representación, es decir, estaríamos hablando + +00:05:55.985 --> 00:05:58.224 +de una columna o estaríamos hablando de un + +00:05:58.224 --> 00:06:05.330 +renglón. Así pues, vamos a considerar con el + +00:06:05.330 --> 00:06:09.330 +ejemplo anterior dos vectores AYBY vamos a definir + +00:06:09.330 --> 00:06:14.985 +la operación a traspuesta b como a traspuesto + +00:06:15.285 --> 00:06:18.165 +b igual a este vector renglón, ya vimos + +00:06:18.165 --> 00:06:21.845 +que a traspuesto era este de aquí, y + +00:06:21.845 --> 00:06:25.170 +bit es simplemente este vector de aquí. Nosotros + +00:06:25.170 --> 00:06:27.010 +dijimos desde acá que el estándar iba a + +00:06:27.010 --> 00:06:31.090 +ser pensar en vectores columna. Ahora bien, esto + +00:06:31.090 --> 00:06:33.010 +que sucede aquí es lo que se llama + +00:06:33.010 --> 00:06:36.370 +la ley del caratazo. Imagina que tienes este + +00:06:36.370 --> 00:06:39.215 +abrazo aquí y tienes el otro brazo aquí, + +00:06:39.435 --> 00:06:41.695 +entonces vas a cambiar la posición del brazo. + +00:06:41.995 --> 00:06:44.255 +La ley del caratazo es algo muy sencillo, + +00:06:44.555 --> 00:06:46.955 +vas a empezar con un vector renglón y + +00:06:46.955 --> 00:06:49.294 +lo vas a multiplicar por un vector columna. + +00:06:49.770 --> 00:06:52.650 +Es decir, cada uno de estos elementos del + +00:06:52.650 --> 00:06:55.050 +renglón lo vas a multiplicar por cada uno + +00:06:55.050 --> 00:06:57.450 +de los elementos de este vector columna y + +00:06:57.450 --> 00:07:00.490 +adivina cuál va a ser el resultado. Un + +00:07:00.490 --> 00:07:05.645 +escalar. Regresemos a la computadora. Ahora bien, esto + +00:07:05.645 --> 00:07:08.685 +quiere decir que tomemos el a, y el + +00:07:08.685 --> 00:07:10.945 +a lo vamos a multiplicar por el b + +00:07:11.245 --> 00:07:13.745 +cero, a cero por b cero, aquí está. + +00:07:14.044 --> 00:07:15.645 +Y a eso le vamos a sumar el + +00:07:15.645 --> 00:07:17.665 +a uno por el b uno, aquí está, + +00:07:17.805 --> 00:07:19.099 +y a eso le vamos a sumar el + +00:07:19.099 --> 00:07:21.140 +a dos por el b dos, y así + +00:07:21.140 --> 00:07:23.460 +hasta el enésimo elemento, que sería el a + +00:07:23.460 --> 00:07:25.620 +n por el b n, que es esta + +00:07:25.620 --> 00:07:28.340 +suma de aquí. Y otra vez, esto lo + +00:07:28.340 --> 00:07:32.995 +podemos denotar con esta anotación de aquí. Ahora + +00:07:33.535 --> 00:07:36.895 +bien, esto de aquí coincide exactamente con la + +00:07:36.895 --> 00:07:41.475 +definición que nosotros dimos de producto punto. Entonces, + +00:07:41.775 --> 00:07:44.095 +otra forma de poder representar el producto punto + +00:07:44.095 --> 00:07:47.750 +entre vectores será esta, un vector transpuesto por + +00:07:47.750 --> 00:07:51.370 +un vector. Es justamente lo que mencionamos aquí. + +00:07:52.790 --> 00:07:56.550 +El producto interno denotado así, con un producto + +00:07:56.550 --> 00:07:59.365 +medio, o como la multiplicación de dos vectores + +00:07:59.365 --> 00:08:03.205 +de esta forma, es exactamente lo mismo, es + +00:08:03.205 --> 00:08:09.205 +la multiplicación de sus elementos y la suma + +00:08:09.205 --> 00:08:12.245 +de estos, que es exactamente eso lo que + +00:08:12.245 --> 00:08:16.389 +nos dice. Ahora bien, vamos a ver algunas + +00:08:16.389 --> 00:08:20.870 +propiedades del producto interno. Vamos a definir AAYB + +00:08:20.870 --> 00:08:23.030 +dos n vectores cualesquiera y a alfa un + +00:08:23.030 --> 00:08:26.710 +escalar cualquiera. Sabemos que el producto interno entre + +00:08:26.710 --> 00:08:31.545 +AYB va a cumplir las siguientes propiedades. Este + +00:08:31.545 --> 00:08:34.905 +también cumple la conmutatividad, pero hay que tener + +00:08:34.905 --> 00:08:39.065 +mucho cuidado. En este caso, la conmutatividad se + +00:08:39.065 --> 00:08:41.870 +da de esta forma, a traspuesto b es + +00:08:41.870 --> 00:08:45.070 +igual, sabemos, por este de aquí arriba, a + +00:08:45.070 --> 00:08:48.450 +la suma de la multiplicación de los elementos + +00:08:49.709 --> 00:08:51.950 +de la de las de los coeficientes, de + +00:08:51.950 --> 00:08:54.910 +las entradas individuales de AYB, es decir, los + +00:08:54.910 --> 00:08:57.765 +AIY los b I. Ahora, sabemos que estos + +00:08:57.765 --> 00:09:00.405 +de aquí son escalares y la multiplicación entre + +00:09:00.405 --> 00:09:03.365 +escalares siempre conmuta, es decir, a I por + +00:09:03.365 --> 00:09:04.965 +b I es lo mismo que b I + +00:09:04.965 --> 00:09:08.745 +por a I. Usando ese hecho podemos escribir + +00:09:09.045 --> 00:09:12.120 +esta relación de aquí también. Entonces, da lo + +00:09:12.120 --> 00:09:15.660 +mismo si multiplicamos a I por BIY sumamos + +00:09:16.120 --> 00:09:18.620 +los a I por los BI0 si sumamos + +00:09:18.760 --> 00:09:22.600 +los b I por los AIY esto de + +00:09:22.600 --> 00:09:25.660 +aquí es exactamente la representación de b traspuesta + +00:09:25.880 --> 00:09:28.995 +por a. Entonces conmuta de la siguiente forma, + +00:09:29.055 --> 00:09:31.215 +a traspuesta por b es igual a b + +00:09:31.215 --> 00:09:36.415 +traspuesta por a. Ahora, viene la asociatividad con + +00:09:36.415 --> 00:09:41.730 +multiplicación escalar. En esta asociatividad nosotros tenemos que + +00:09:41.870 --> 00:09:44.910 +a por alfa por a sabemos que esto + +00:09:44.910 --> 00:09:48.750 +es un n vector, entonces transponemos toda esta + +00:09:48.750 --> 00:09:50.510 +operación de aquí porque este es un n + +00:09:50.510 --> 00:09:53.310 +vector, y este n vector lo multiplicamos por + +00:09:53.310 --> 00:09:56.535 +b. Lo que nos dice la asociatividad con + +00:09:56.535 --> 00:10:00.475 +la multiplicación escalar es que da lo mismo + +00:10:01.335 --> 00:10:04.855 +que multipliquemos primero este escalar, es decir, que + +00:10:04.855 --> 00:10:09.079 +escalemos este vector, y después lo transpongamos y + +00:10:09.079 --> 00:10:12.040 +después lo multipliquemos por b, que si hacemos + +00:10:12.040 --> 00:10:15.959 +la multiplicación a traspuesta por b y después + +00:10:15.959 --> 00:10:21.565 +lo escalamos por el escalar alfa. Una forma + +00:10:21.565 --> 00:10:24.445 +de decirlo, y que también se suele utilizar, + +00:10:24.445 --> 00:10:29.185 +es que el escalar saca escalares, la transposición + +00:10:29.644 --> 00:10:32.785 +saca escalares. Ahora, vamos a ver la distribución + +00:10:32.925 --> 00:10:36.170 +en la adición de vectores. Notemos que si + +00:10:36.170 --> 00:10:38.850 +sumamos AYB, esto nos va a dar un + +00:10:38.850 --> 00:10:41.570 +n vector, y todo este n vector lo + +00:10:41.570 --> 00:10:46.470 +podemos transponer. Y toda esa transposición la multiplicamos + +00:10:46.850 --> 00:10:49.654 +por c, y eso nos daría un escalar, + +00:10:50.915 --> 00:10:54.115 +donde tanto c como b como a son + +00:10:54.115 --> 00:10:58.375 +n vectores. Así bien, lo que la distribución + +00:10:58.514 --> 00:11:00.274 +en la adición de vectores nos dice es + +00:11:00.274 --> 00:11:03.410 +que da lo mismo sumarlo y después transponerlo + +00:11:03.410 --> 00:11:07.650 +y después multiplicarlo por c, que si sumamos + +00:11:07.650 --> 00:11:10.130 +la multiplicación de la transposición de a por + +00:11:10.130 --> 00:11:12.930 +c y la de la transposición de b + +00:11:12.930 --> 00:11:16.705 +por c. Esto será exactamente lo mismo. Hasta + +00:11:16.705 --> 00:11:19.665 +aquí llega esta clase. Hay que hacer un + +00:11:19.665 --> 00:11:21.505 +pequeño recap de lo que hemos visto hasta + +00:11:21.505 --> 00:11:24.145 +ahora. Hasta el momento ya vimos tres tipos + +00:11:24.145 --> 00:11:26.705 +de operaciones con los vectores súper importantes, que + +00:11:26.705 --> 00:11:30.020 +es la suma de vectores, la multiplicación de + +00:11:30.020 --> 00:11:33.380 +escalares por vectores, y ahora vimos esta nueva + +00:11:33.380 --> 00:11:36.520 +operación entre vectores que se denomina producto escalar. + +00:11:37.220 --> 00:11:41.800 +Solamente para recapitular, la operación suma entre vectores + +00:11:42.735 --> 00:11:45.135 +nos daba un vector más, es decir, si + +00:11:45.135 --> 00:11:48.175 +sumábamos dos n vectores, lo que obteníamos como + +00:11:48.175 --> 00:11:50.815 +respuesta era un n vector. En el caso + +00:11:50.815 --> 00:11:52.735 +de la multiplicación de un escalar por un + +00:11:52.735 --> 00:11:55.455 +n vector, sabíamos que nos daba también un + +00:11:55.455 --> 00:11:57.839 +escalar, y como vimos, lo que hace multiplicarlo + +00:11:58.060 --> 00:12:00.000 +por un escalar es que lo puede magnificar, + +00:12:00.220 --> 00:12:04.000 +es decir, crece su magnitud, lo puede también + +00:12:04.220 --> 00:12:07.740 +achicar, puede hacer que su magnitud decrezca y, + +00:12:07.740 --> 00:12:10.905 +de igual manera, le puede cambiar su sentido, + +00:12:10.905 --> 00:12:14.025 +es decir, puede apuntar en el sentido contrario, + +00:12:14.025 --> 00:12:17.565 +y lo puede magnificar o lo puede encoger + +00:12:17.625 --> 00:12:23.625 +en el sentido contrario. El producto interno lo + +00:12:23.625 --> 00:12:26.860 +que nos dará, entonces, será un escalar, es + +00:12:26.860 --> 00:12:30.540 +decir, tomará dos n vectores, los juntará y + +00:12:30.540 --> 00:12:34.380 +nos dará un número. Esa es la diferencia + +00:12:34.380 --> 00:12:36.540 +entre las tres operaciones que hemos visto hasta + +00:12:36.540 --> 00:12:39.933 +ahora. Nos vemos en la próxima clase, en + +00:12:39.933 --> 00:12:42.893 +donde veremos algunas consideraciones y cómo realizar estas + +00:12:42.893 --> 00:12:45.633 +operaciones en Python. Nos vemos allá. diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Resumen.html" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Resumen.html" new file mode 100644 index 0000000000000000000000000000000000000000..255ee21ded4d66490e8b0f65985e6e365f4b4320 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-Resumen.html" @@ -0,0 +1,133 @@ + + + + + + + Producto Interno de Vectores: Definición y Propiedades + + + +
+
+

Resumen

¿Qué es el producto interno?

+

El conocimiento matemático siempre parece más complejo de lo que es, pero el objetivo es hacer estas nociones más accesibles. Hoy exploraremos el producto interno, una operación especial entre vectores, que promete enriquecer nuestra caja de herramientas matemáticas. Esta operación, conocida también como producto punto, implica la suma de la multiplicación de sus entradas de extremo a extremo, generando un escalar como resultado. Atrévete a descubrir cómo esta operación puede simplificar y forjar una conexión esencial entre tus vectores preferidos.

+

¿Cómo se define el producto interno de vectores?

+

El producto interno se aplica a n vectores, y su notación puede variar; desde la típica de corchetes rectos hasta la representación de un punto en centro. Matemáticamente, se define como:

+

[ +\textstyle \sum_{i=0}^{n-1} a_i \cdot b_i +]

+

Para ilustrarlo con un ejemplo, si tenemos el vector ( a = (1, 2, 3) ) y el vector ( b = (4, 5, 6) ), el producto punto de a y b sería:

+

[ +1 \cdot 4 + 2 \cdot 5 + 3 \cdot 6 = 4 + 10 + 18 = 32 +]

+

Al final de esta operación, pasamos de tener dos vectores a obtener un número: 32. Este escalar es precisamente lo que fortalece la teoría tras el producto interno.

+

¿Investigamos la transposición de vectores?

+

Una herramienta clave al trabajar con vectores es la transposición. Esta operación cambia la forma de un vector de columna a vector renglón o viceversa. Considerando un vector columna ( a = (1, 2, 3)^T ), su transposición sería ( a^T = (1, 2, 3) ). Es fascinante cómo realizando la operación inversa, es decir, transponiendo nuevamente, regresamos al vector original.

+

Veamos un caso práctico con la transposición: cuando ( a ) es un vector columna y lo transponemos, obtenemos un vector renglón que permite multiplicarse por otro vector columna, logrando así obtener la misma definición del producto punto.

+

¿Cuáles son las propiedades del producto interno?

+

Explorar las propiedades del producto interno nos ofrece más flexibilidad:

+
    +
  1. +

    Conmutatividad: La multiplicación entre los elementos de ( a ) y ( b ) siempre conmuta, es decir:

    +

    [ +a^T \cdot b = b^T \cdot a +]

    +
    2. +
  2. +

    Asociatividad con la multiplicación escalar: La operación no altera al producto interno cuando multiplicamos por un escalar:

    +

    [ +(\alpha \cdot a)^T \cdot b = \alpha \cdot (a^T \cdot b) +]

    +
    3. +
  3. +

    Distributividad sobre la adición de vectores: Facilita efectuar la operación en pasos:

    +

    [ +(a + b)^T \cdot c = a^T \cdot c + b^T \cdot c +]

    +
    4. +
+

Hemos discutido hasta ahora la suma de vectores, la multiplicación de escalares por vectores, y hoy el producto interno. Mientras la suma y la multiplicación escalar nos devuelven vectores, el producto interno resulta en un escalar. Estos conceptos son esenciales en el análisis vectorial y aplicaciones como la física y el análisis de datos.

+

Te invito a seguir explorando y aplicando estos fundamentos matemáticos en tus proyectos. ¡La práctica constante te hará dominar estas herramientas!

+
+
+ + \ No newline at end of file diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-producto_interno_a8f30484-9414-46fd-849b-c4125cd68a19.ipynb" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-producto_interno_a8f30484-9414-46fd-849b-c4125cd68a19.ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..967cc0b06914e94793a8eeae06d0a77112ba6a24 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/08-producto_interno_a8f30484-9414-46fd-849b-c4125cd68a19.ipynb" @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. Producto Interno" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El *producto interno* (estándar) o simplemente *producto punto* de dos $n$-vectores $\\vec{a},\\vec{b}$ se define como el escalar:\n", + "\n", + "$$\n", + "<\\vec{a},\\vec{b}> = \\vec{a} \\cdot \\vec{b} = a_{0}b_{0}+a_{1}b_{1}+\\cdots+a_{n-1}b_{n-1} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}\n", + "$$\n", + "\n", + "Que es simplemente la suma del producto de sus entradas." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Por ejemplo, si $\\vec{a}=(1,2,3)$ y $\\vec{b}=(4,5,6)$ entonces el producto punto será:\n", + "\n", + "$$\n", + "\\vec{a}\\cdot\\vec{b} = (1,2,3)\\cdot (4,5,6) = 1\\cdot 4+2\\cdot 5 + 3\\cdot 6 = 4+10+18=32\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hasta ahora trabajamos de forma indiferente con *vectores columna* y *vectores renglón*, a partir de este momento **el estándar serán los vectores columna** entonces simpre que hablemos de un vector, dígamos $\\vec{a}$ entonces estaremos hablando del vector columna:\n", + "\n", + "$$\n", + "\\vec{a} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Esto también nos permite introducir una nueva operación: **la transposición**. Retomemos el vector $\\vec{a}$, denotaremos como $\\vec{a}^{T}$ al vector transpuesto de $\\vec{a}$:\n", + "\n", + "$$\n", + "\\vec{a}^{T} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}^{T} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}]\n", + "$$\n", + "\n", + "La operación de transposición nos permite cambiar de vectores columna a vectores renglón sin modificar al vector que se transponga. Notemos que es posible poder transponer un vector transpuesto_\n", + "\n", + "$$\n", + "\\left(\\vec{a}^{T}\\right)^{T} = \\left(\\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}^{T}\\right)^{T} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}]^{T} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix} = \\vec{a}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Así pues, consideremos el ejemplo anterior de los vectores $\\vec{a}$ y $\\vec{b}$. Definimos la operación $\\vec{a}^{T}\\vec{b}$ como:\n", + "\n", + "$$\n", + "\\vec{a}^{T}\\; \\vec{b} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}] \\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{n-1}\\end{bmatrix} = a_{0}b_{0} + a_{1}b_{1} + \\cdots + a_{n-1}b_{n-1} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}\n", + "$$\n", + "\n", + "Lo cual coincide con la definición del producto interno. Así pues $<\\vec{a},\\vec{b}> = \\vec{a}\\cdot \\vec{b} = \\vec{a}^{T} \\;\\vec{b} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.1 Propiedades del producto interno" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sean $\\vec{a},\\vec{b}$ dos $n$-vectores y $\\alpha$ un escalar. El producto interno entre $\\vec{a}$ y $\\vec{b}$ cumple las siguientes propiedades:\n", + "\n", + "* Conmutatividad: $\\vec{a}^{T}\\vec{b} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i} = \\displaystyle\\sum_{i=0}^{n-1} b_{i}a_{i} = \\vec{b}^{T}\\vec{a}$\n", + "\n", + "* Asociatividad con multiplicación escalar: $\\left(\\alpha \\vec{a}\\right)^{T}\\vec{b} = \\alpha\\left(\\vec{a}^{T}\\vec{b}\\right)$\n", + "\n", + "* Distribución en la adición de vectores: $\\left(\\vec{a} + \\vec{b}\\right)^{T}\\vec{c} = \\vec{a}^{T}\\vec{c} + \\vec{b}^{T}\\vec{c}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.2 Consideraciones adicionales" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Proyección**. Si $\\vec{a}$ es un $n$-vector entonces $\\hat{e}_{i}^{T}\\vec{a} = a_{i}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Suma de elementos de un vector.** $\\mathbf{1}^{T}a = a_{0}+a_{1}+\\cdots+a_{n-1}$ " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Promedio de entradas de un vector.** $(\\mathbf{1}/n)^{T}\\vec{a} = (a_{0}+a_{1}+\\cdots+a_{n-1})/n$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Suma de cuadrados de un vector.** $\\vec{a}^{T} \\;\\vec{a} = a_{0}^{2}+a_{1}^{2}+\\cdots+a_{n-1}^{2}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Producto interno de bloques de vectores**. Sean $\\vec{a},\\vec{b}$ $k$-vectores formados por concatenar los $n$-vectores $a_{i},b_{i}$:\n", + "\n", + "$$\n", + "\\vec{a}=\\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{k-1}\\end{bmatrix},\\qquad \\vec{b}=\\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{k-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Entonces el producto punto entre estos vectores va como:\n", + "\n", + "$$\n", + "\\vec{a}^{T} \\vec{b} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{k-1}]\\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{k-1}\\end{bmatrix} = a_{0}^{T}b_{0}+a_{1}^{T}b_{1} + \\cdots + a_{k-1}^{T}b_{k-1}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.3 Producto interno en Python. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sean $\\vec{a},\\vec{b}$ vectores en $\\mathbb{R}^{4}$. Diremos que los vectores son **ortogonales** o **perpendiculares** si $\\vec{a}\\cdot \\vec{b}= 0$\n", + "\n", + "Consideremos entonces $\\vec{a}=\\hat{e}_{0}$ y $\\vec{b} = \\hat{e}_{2}$. Vamos a realizar el producto punto en Python" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([1,0,0,0]) #declaramos el vector e_1\n", + "\n", + "b = np.array([0,0,1,0]) #declaramos el vector e_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para realizar el producto punto llamaremos a la función *numpy.dot*" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " = 0\n" + ] + } + ], + "source": [ + "print(' =',np.dot(a,b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "De igual manera también podemos usar el operador $@$" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " = 0\n" + ] + } + ], + "source": [ + "print(' =',a.T@b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Evaluación de polinomios**. Un polinomio de grado $n-1$ se puede expresar como $p(x) = c_{0} + c_{1}x + c_{2}x^{2} + \\cdots + c_{n-1}x^{n-1}$. Si consideramos los $n$-vectores $\\vec{c},\\vec{x}$ tales que:\n", + "\n", + "$$\n", + "\\vec{c} = \\begin{bmatrix}c_{0}\\\\ c_{1}\\\\ \\vdots \\\\ c_{n-1}\\end{bmatrix},\\qquad \\vec{x}(x) = \\begin{bmatrix}x^{0}\\\\ x^{1}\\\\ \\vdots \\\\ x^{n-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Así pues, usando estos vectores es posible expresar $p(x) = \\vec{c}^{T}\\vec{x}(x)$. Un ejemplo más concreto sería $p(x)=1+2x$, usando los vectores:\n", + "\n", + "$$\n", + "\\vec{c} = \\begin{bmatrix}1\\\\ 2 \\end{bmatrix}, \\qquad \\vec{x}(x) = \\begin{bmatrix}1\\\\ x \\end{bmatrix}\n", + "$$\n", + "\n", + "Entonces podemos escribir:\n", + "$$\n", + "p(x) = \\vec{c}^{T}\\vec{x}(x) = [1 \\; 2] \\begin{bmatrix}1\\\\ x \\end{bmatrix} = 1\\cdot 1 + 2\\cdot x = 1 + 2x\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Así pues en Python podemos escribir el polinomio como:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def p(x):\n", + " return np.array([1,2])@np.array([1,x])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "p(0) = 1\n", + "p(1) = 3\n", + "p(2) = 5\n" + ] + } + ], + "source": [ + "print('p(0) = ',p(0))\n", + "print('p(1) = ',p(1))\n", + "print('p(2) = ',p(2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.4 Ejercicios." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 1: Análisis de sentimientos de tweets.** Vamos a crear un máquina que pueda decirnos qué tan positivo, neutral o negativo son una serie de respuestas de twitter. \n", + "Las respuestas son:\n", + "> Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!\n", + "\n", + "> Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.\n", + "\n", + "> Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien.\n", + "Un saludo\n", + "\n", + "> Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "a = \"Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!\"\n", + "a = a.replace(\"!\",\"\").replace(\",\",\"\").split(\" \")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Gran',\n", + " 'mexicano',\n", + " 'y',\n", + " 'excelente',\n", + " 'en',\n", + " 'su',\n", + " 'área',\n", + " 'su',\n", + " 'muerte',\n", + " 'es',\n", + " 'una',\n", + " 'enorme',\n", + " 'perdida',\n", + " 'y',\n", + " 'debería',\n", + " 'ser',\n", + " 'luto',\n", + " 'nacional']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sí\n" + ] + } + ], + "source": [ + "if 'muerte' in a:\n", + " print(\"Sí\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora bien, no podemos sacar toda la información de los textos sino vamos a buscar cadenas (strings) específicas. Así pues vamos a construir una función de Python que cuente la cantidad de veces que aparece cierta cadena. Como ejemplo, supongamos que las palabras que vamos a contar son *muerte*, *pérdida*, *luto*, *excelente*,*gran* y *positivo*, y además esto lo queremos expresar como vector en orden respectivo, así pues el primer comentario lo podemos expresar como el siguiente vector:\n", + "$$\n", + "\\vec{w} = \\begin{bmatrix}1\\\\ 1 \\\\ 1\\\\ 1\\\\ 1 \\\\0 \\end{bmatrix}\n", + "$$\n", + "Ahora, vamos a crear otra función en la que tendremos el vector con entradas de cantidad de palabras positivas, negativas y neutras. Siguiendo con el ejemplo vamos a sumar un uno a la primer entrada si aparece alguna de las siguientes palabras *excelente*,*gran* y *positivo*, un uno en la segunda por cada vez que aparezca la palabra *pérdida* y un uno a la última entrada si aparecen las palabras *muerte* y *luto*. Así pues, el primer twett lo podemos representar como:\n", + "\n", + "$$\n", + "\\vec{s} = \\begin{bmatrix} 2 \\\\ 1 \\\\2 \\end{bmatrix}\n", + "$$\n", + "\n", + "Ahora, para ver la *calidad* del resultado que tendremos para un twett conviene calcular el promedio de las entradas de un vector de palabras\n", + "$$avg(\\vec{w}) = (\\mathbf{1}/n)^{T}\\vec{w}$$\n", + "Y después calcularás el promedio del sentimiento de cada tweet $avg(\\vec{s})$ y de igual manera el *score sentimental* que se define como \n", + "$$score(\\vec{s}) = [1\\; 0\\; -1] \\begin{bmatrix} s_{0} \\\\ s_{1} \\\\s_{2} \\end{bmatrix}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Leyendo los tuits decide el conjunto mínimo de palabras que vas a contar en todos los tuits, solamente deberás hacer una función para contar palabras para todos los tuits, no hagas un función por enunciado. Según tu esquema reponde lo siguiente:\n", + "\n", + "* ¿Qué tuit es más positivo?\n", + "\n", + "* ¿Qué tuit es más negativo?\n", + "\n", + "* ¿Cuál es tu calidad promedio?\n", + "\n", + "* ¿Cómo interpretas $avg(\\vec{s})$ y $score(\\vec{s})$?\n", + "\n", + "* ¿Cómo relacionas la calidad con $score(\\vec{s})$ y $avg(\\vec{s})$?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Lecturas recomendadas.txt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Lecturas recomendadas.txt" new file mode 100644 index 0000000000000000000000000000000000000000..2760ca86f92c5f7fdb9d136373b98526474eb71c --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Lecturas recomendadas.txt" @@ -0,0 +1 @@ +https://colab.research.google.com/drive/1zLgEfmILRmfGXpHHsH5e6gYc9kM7qT5S?usp=sharing diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Producto Interno de Vectores en Python con NumPy.mp4" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Producto Interno de Vectores en Python con NumPy.mp4" new file mode 100644 index 0000000000000000000000000000000000000000..4b033e99d77088fb29dd237abf1bdf395d541652 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Producto Interno de Vectores en Python con NumPy.mp4" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c432aba0dacd891b93d54e99ab58804e292e23b2746088018d16717886712ce +size 114255941 diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Producto Interno de Vectores en Python con NumPy.vtt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Producto Interno de Vectores en Python con NumPy.vtt" new file mode 100644 index 0000000000000000000000000000000000000000..723e3527d599ae3419ac25de193613b5ad4bcaa9 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Producto Interno de Vectores en Python con NumPy.vtt" @@ -0,0 +1,604 @@ +WEBVTT + +00:00:03.120 --> 00:00:05.120 +Te doy la bienvenida de nuevo. En la + +00:00:05.120 --> 00:00:07.919 +clase pasada, lo que vimos fue un breve + +00:00:07.919 --> 00:00:10.400 +repaso de otras operaciones que hemos visto entre + +00:00:10.400 --> 00:00:13.245 +vectores y escalares, y también vimos e introdujimos + +00:00:13.465 --> 00:00:17.225 +una nueva operación, se llama producto interno. Vimos + +00:00:17.225 --> 00:00:19.465 +cómo se realiza de manera algebraica y realizamos + +00:00:19.465 --> 00:00:21.865 +algunos ejercicios a mano. Te invito a que + +00:00:21.865 --> 00:00:24.345 +ahora lo hagamos y aprendamos a hacerlo en + +00:00:24.345 --> 00:00:27.890 +Python. Sin más, vamos a la computadora. Ahora, + +00:00:28.270 --> 00:00:31.869 +antes de llegar a las operaciones en Python, + +00:00:31.869 --> 00:00:34.110 +el producto interno en Python, vamos a ver + +00:00:34.110 --> 00:00:38.290 +algunas consideraciones adicionales. Fíjense que si nosotros tenemos + +00:00:38.350 --> 00:00:40.430 +a como un n vector y hacemos la + +00:00:40.430 --> 00:00:44.495 +multiplicación de el vector unitario estándar e I + +00:00:44.495 --> 00:00:47.875 +traspuesto por a, esto nos da la componente + +00:00:48.015 --> 00:00:50.175 +a I del vector a. A esto le + +00:00:50.175 --> 00:00:54.170 +vamos a llamar una proyección. Es decir, solamente + +00:00:54.170 --> 00:00:57.949 +estamos viendo la iésima componente de este vector + +00:00:58.329 --> 00:01:02.570 +y, como siempre, nos da un escalar. También + +00:01:02.570 --> 00:01:04.729 +vamos a ver que podemos expresar la suma + +00:01:04.729 --> 00:01:06.729 +de los elementos de un vector como la + +00:01:06.729 --> 00:01:11.505 +multiplicación de vectores, es decir, si tomamos el + +00:01:11.505 --> 00:01:14.865 +vector uno, el n vector uno y lo + +00:01:14.865 --> 00:01:18.645 +transponemos, y tenemos a este n vector a, + +00:01:19.104 --> 00:01:21.985 +esto va a ser simplemente la suma de + +00:01:21.985 --> 00:01:25.110 +las componentes del vector a, es decir, a + +00:01:25.110 --> 00:01:27.270 +cero, a uno, a dos, a tres, a + +00:01:27.270 --> 00:01:30.950 +n. Te invito a que realices esta operación + +00:01:30.950 --> 00:01:33.190 +a mano y de manera explícita, al igual + +00:01:33.190 --> 00:01:36.710 +que esta, para que compruebes que el resultado + +00:01:36.710 --> 00:01:42.015 +es correcto. De igual manera, si nosotros tomamos + +00:01:42.075 --> 00:01:45.435 +el vector uno y lo multiplicamos por el + +00:01:45.435 --> 00:01:50.820 +escalar uno sobre n, y además esto lo + +00:01:50.820 --> 00:01:53.720 +transponemos y lo multiplicamos por el vector a, + +00:01:54.180 --> 00:01:58.360 +vamos a obtener el promedio de las entradas + +00:01:58.500 --> 00:02:01.060 +de un vector, o el promedio de un + +00:02:01.060 --> 00:02:04.035 +vector. Esta operación ya la habíamos visto antes, + +00:02:04.035 --> 00:02:06.455 +pero es bueno recordarle y volverla a introducir + +00:02:06.515 --> 00:02:11.315 +aquí. También, la suma de los cuadrados de + +00:02:11.315 --> 00:02:15.075 +un vector se puede expresar como el producto + +00:02:15.075 --> 00:02:18.375 +interno. En este caso, notemos que a traspuesta + +00:02:18.835 --> 00:02:21.770 +por a es igual a a cuadrada más + +00:02:21.770 --> 00:02:24.910 +a uno al cuadrado más a dos cuadrado + +00:02:25.370 --> 00:02:27.690 +más a tres cuadrado, y así hasta el + +00:02:27.690 --> 00:02:30.810 +a n menos uno al cuadrado. Te invito + +00:02:30.810 --> 00:02:33.790 +a que realices todas estas operaciones a mano + +00:02:34.305 --> 00:02:37.185 +con vectores, digamos, en r tres y que + +00:02:37.185 --> 00:02:41.265 +puedas verificar que esto es cierto. También otra + +00:02:41.265 --> 00:02:42.944 +cosa muy interna que en el futuro nos + +00:02:42.944 --> 00:02:46.144 +servirá es el producto interno entre bloques de + +00:02:46.144 --> 00:02:50.530 +vectores. Si recordamos, nosotros teníamos la definición de + +00:02:50.530 --> 00:02:54.050 +bloques de vectores como n vectores, cuyos elementos + +00:02:54.050 --> 00:02:59.170 +eran k vectores. Entonces, consideremos AYBK vectores formados + +00:02:59.170 --> 00:03:03.254 +al concatenar los n vectores AIYBI. Vamos a + +00:03:03.635 --> 00:03:08.915 +considerar que son, como son k vectores, KAIYKBI + +00:03:08.915 --> 00:03:13.875 +vectores. Entonces, a es un k vector y + +00:03:13.875 --> 00:03:16.674 +cada una de sus entradas aquí es un + +00:03:16.674 --> 00:03:19.349 +n vector. Tenemos el n vector a cero, + +00:03:19.349 --> 00:03:21.430 +el n vector a uno, así hasta el + +00:03:21.430 --> 00:03:25.590 +n vector k menos uno. De igual manera, + +00:03:25.590 --> 00:03:28.870 +con b. Tenemos el vector el n vector + +00:03:28.870 --> 00:03:30.709 +b cero en el n vector b uno + +00:03:30.709 --> 00:03:33.209 +hasta el n vector b k menos uno. + +00:03:33.375 --> 00:03:38.035 +AYB son k vectores, mientras que los coeficientes + +00:03:38.335 --> 00:03:42.975 +de aquí son en realidad n vectores. Así, + +00:03:42.975 --> 00:03:46.815 +pues, el producto punto entre estos vectores lo + +00:03:46.815 --> 00:03:50.459 +podemos denotar como a traspuesta por b, como + +00:03:50.459 --> 00:03:53.260 +hemos visto hasta ahora, que es simplemente este + +00:03:53.260 --> 00:03:57.120 +vector renglón por este vector columna. Sin embargo, + +00:03:58.219 --> 00:04:02.334 +esto nos da como resultado este de aquí + +00:04:02.474 --> 00:04:07.674 +transpuesto por este de aquí normal. Te invito + +00:04:07.674 --> 00:04:10.415 +a que llegues a este resultado, sin embargo, + +00:04:10.474 --> 00:04:16.810 +este resultado es cierto. Entonces, el producto interno + +00:04:17.589 --> 00:04:20.950 +entre dos bloques de vectores será igual a + +00:04:20.950 --> 00:04:24.550 +la suma de los productos internos entrada por + +00:04:24.550 --> 00:04:28.544 +entrada de los vectores que componen a esos + +00:04:30.205 --> 00:04:36.604 +a esos bloques de vectores. Ahora bien, vamos + +00:04:36.604 --> 00:04:38.444 +a entrar de lleno con el producto interno + +00:04:38.444 --> 00:04:41.245 +en Python. Para eso primero vamos a importar + +00:04:41.245 --> 00:04:45.849 +numpy. Después, vamos a aclarar AYB dos vectores + +00:04:45.849 --> 00:04:49.050 +en r cuatro. Algo muy importante o una + +00:04:49.050 --> 00:04:51.849 +propiedad importante es que diremos que estos vectores + +00:04:51.849 --> 00:04:56.694 +son ortogonales o perpendiculares si el producto interno + +00:04:56.835 --> 00:05:02.294 +de AYB es cero. Así, pues, consideremos entonces + +00:05:02.754 --> 00:05:05.315 +a a igual a e cero YAB igual + +00:05:05.315 --> 00:05:08.880 +a e dos, dentro de r cuatro, realicemos + +00:05:08.940 --> 00:05:12.000 +el producto punto de esos vectores en Python. + +00:05:12.860 --> 00:05:16.060 +Estos vectores ya los conocemos porque se quedaron + +00:05:16.060 --> 00:05:19.740 +como ejercicio hace dos clases. Si no, de + +00:05:19.740 --> 00:05:22.325 +todas maneras lo recuerdo, el vector e uno + +00:05:22.325 --> 00:05:24.725 +es el vector uno coma cero coma cero + +00:05:24.725 --> 00:05:26.965 +coma cero, y el vector e dos será + +00:05:26.965 --> 00:05:29.605 +el vector cero coma cero coma uno coma + +00:05:29.605 --> 00:05:38.290 +cero. Si nosotros realizamos el producto punto, lo + +00:05:38.290 --> 00:05:41.370 +podemos realizar a mano, nos daremos cuenta que + +00:05:41.370 --> 00:05:44.770 +este de aquí nos dará cero, ya que + +00:05:44.770 --> 00:05:48.450 +uno por cero es cero, más cero por + +00:05:48.450 --> 00:05:50.844 +cero, que es cero, Cero por cero, que + +00:05:50.844 --> 00:05:52.525 +es cero, más cero por cero, que es + +00:05:52.525 --> 00:05:56.365 +cero. Entonces, este producto punto, el producto punto + +00:05:56.365 --> 00:05:57.805 +entre e uno y e dos, o en + +00:05:57.805 --> 00:05:59.965 +este caso AYB, nos debería de durar un + +00:05:59.965 --> 00:06:03.164 +cero. Ahora, la forma de realizar el producto + +00:06:03.164 --> 00:06:07.389 +punto entre AYB en numpy se llama con + +00:06:07.389 --> 00:06:14.690 +la función numpy dot. Entonces llamaremos print, el + +00:06:14.910 --> 00:06:17.355 +producto punto de AYB igual, y esta es + +00:06:17.355 --> 00:06:20.895 +la operación que hacemos, n p dot AYB. + +00:06:20.955 --> 00:06:22.955 +Si te das cuenta, no hay necesidad de + +00:06:22.955 --> 00:06:25.215 +transponer, no hay necesidad de hacer ninguna operación + +00:06:25.995 --> 00:06:30.790 +adicional, simplemente llamamos n p punto dot a + +00:06:30.790 --> 00:06:33.270 +coma b, y nos da el resultado que + +00:06:33.270 --> 00:06:37.990 +estábamos esperando. De igual manera, cuando estemos hablando + +00:06:37.990 --> 00:06:40.490 +de vectores y en el futuro de matrices, + +00:06:41.030 --> 00:06:45.074 +podemos utilizar el operador arroba. Este operador dentro + +00:06:45.074 --> 00:06:48.995 +de NumPy o entre entre elementos de NumPy + +00:06:48.995 --> 00:06:52.354 +sean matrices o sean vectores, representa para ellos + +00:06:52.354 --> 00:06:56.835 +la multiplicación. Y entonces, si nosotros agarramos dos + +00:06:56.835 --> 00:07:00.930 +vectores, en este caso, el vector a y + +00:07:00.930 --> 00:07:03.330 +el vector b, y además al vector a + +00:07:03.330 --> 00:07:08.449 +lo transponemos, nos daremos cuenta que el producto + +00:07:08.449 --> 00:07:12.605 +punto es simplemente cero, y es que esta + +00:07:12.905 --> 00:07:14.845 +representación que tenemos de aquí es la multiplicación + +00:07:15.145 --> 00:07:18.665 +entre vectores, exactamente esta que hemos estado viendo + +00:07:18.665 --> 00:07:23.785 +acá. Ahora bien, vamos a poner un ejemplo + +00:07:23.785 --> 00:07:27.380 +más claro. Un polinomio de grado n menos + +00:07:27.380 --> 00:07:30.760 +uno se puede expresar como esta combinación lineal, + +00:07:33.860 --> 00:07:39.080 +donde los c ceros son constantes ya dadas + +00:07:40.005 --> 00:07:46.805 +y los x son el número que estamos + +00:07:46.805 --> 00:07:52.264 +introduciendo. Por ejemplo, si este fuera un cero, + +00:07:53.150 --> 00:07:56.349 +este de aquí sería cero por c uno, + +00:07:56.349 --> 00:07:59.710 +cero por c dos, cero por c n + +00:07:59.710 --> 00:08:03.330 +menos uno, y nos daría únicamente c cero. + +00:08:04.990 --> 00:08:09.685 +Ahora, si consideramos dos n vectores CYX, tales + +00:08:09.685 --> 00:08:14.005 +que esos n vectores son c cero, c + +00:08:14.005 --> 00:08:16.824 +uno, c dos, hasta c n menos uno, + +00:08:17.044 --> 00:08:21.625 +y consideramos también un vector función, más adelante + +00:08:22.085 --> 00:08:24.370 +veremos cómo definir estos de manera correcta, pero + +00:08:24.370 --> 00:08:26.530 +simplemente lo que nosotros le vamos a meter + +00:08:26.530 --> 00:08:29.330 +a este vector es un número. Si le + +00:08:29.330 --> 00:08:31.570 +ponemos un cero, por ejemplo, aquí sería cero + +00:08:31.570 --> 00:08:34.929 +a la cero, que es un cero. Cero + +00:08:34.929 --> 00:08:37.169 +a la uno, que es un cero, y + +00:08:37.169 --> 00:08:39.010 +cero a la n menos uno, que nos + +00:08:39.010 --> 00:08:43.145 +dará un cero. Entonces, en ese caso, si + +00:08:43.145 --> 00:08:46.425 +nosotros ponemos un uno, nos dará c uno + +00:08:46.425 --> 00:08:50.665 +a la cero, que es Ese te lo + +00:08:50.665 --> 00:08:53.225 +dejo a ti. Uno a la uno, que + +00:08:53.225 --> 00:08:55.540 +es uno, y uno a la n menos + +00:08:55.540 --> 00:09:00.180 +uno, que será uno también, y así podemos + +00:09:00.180 --> 00:09:11.345 +seguirlo haciendo. Ahora bien, usando estos vectores, el + +00:09:11.345 --> 00:09:15.584 +vector c y el vector XDX, va a + +00:09:15.584 --> 00:09:20.520 +ser posible expresar este polinomio de aquí como + +00:09:20.580 --> 00:09:24.820 +esta multiplicación de vectores de acá. Si ponemos + +00:09:24.820 --> 00:09:28.280 +un ejemplo más concreto o mucho más tangible, + +00:09:28.820 --> 00:09:31.780 +lo podríamos poner como el polinomio uno más + +00:09:31.780 --> 00:09:37.065 +dos x. Usando los vectores c igual a + +00:09:37.065 --> 00:09:39.785 +uno dos y x de x igual a + +00:09:39.785 --> 00:09:46.125 +uno x. Y así podemos escribir p igual + +00:09:46.340 --> 00:09:49.640 +a c traspuesta por XDX, que es igual + +00:09:49.700 --> 00:09:53.140 +al uno dos, por el uno x, y + +00:09:53.140 --> 00:09:55.060 +esto es igual a uno por uno, que + +00:09:55.060 --> 00:09:57.780 +es uno por uno, más dos por x, + +00:09:57.780 --> 00:10:00.065 +dos por x. Y esto nos da uno + +00:10:00.065 --> 00:10:03.285 +más dos x, que es exactamente nuestro polinomio. + +00:10:03.345 --> 00:10:08.964 +Ahora, vamos a definir este polinomio en Python. + +00:10:09.345 --> 00:10:12.305 +¿Cómo lo haríamos? Vamos a definir la función + +00:10:12.305 --> 00:10:14.404 +pdx y lo que nos va a regresar + +00:10:14.730 --> 00:10:18.510 +va a ser el array n p uno + +00:10:18.570 --> 00:10:22.190 +coma dos, que es este de aquí, multiplicado + +00:10:23.690 --> 00:10:28.810 +por el array uno coma x, que es + +00:10:28.810 --> 00:10:32.725 +este de aquí. Y ahora, si nosotros evaluamos + +00:10:33.425 --> 00:10:36.225 +este polinomio en cero, por ejemplo, evaluándolo en + +00:10:36.225 --> 00:10:39.904 +cero sabemos que cero por dos x, esto + +00:10:39.904 --> 00:10:41.524 +de aquí nos va a dar un cero + +00:10:41.584 --> 00:10:47.240 +y nos daría un uno. Entonces, evaluando p + +00:10:47.240 --> 00:10:50.520 +en cero nos debería de dar uno, y + +00:10:50.520 --> 00:10:54.620 +aquí está exactamente. Y no hicimos esta función, + +00:10:54.680 --> 00:10:57.980 +sino hicimos esta multiplicación de vectores de acá. + +00:10:58.465 --> 00:11:02.225 +Ahora, vamos a ver qué nos daría evaluarlo + +00:11:02.225 --> 00:11:06.225 +en el uno. Si nosotros evaluamos en el + +00:11:06.225 --> 00:11:09.425 +uno, veamos de la fórmula de aquí, tenemos + +00:11:09.425 --> 00:11:12.645 +uno más dos por uno, que sería tres. + +00:11:13.140 --> 00:11:16.020 +Entonces, esto, p de uno, nos estaría dando + +00:11:16.020 --> 00:11:19.220 +tres, y ya tenemos que p cero es + +00:11:19.220 --> 00:11:22.360 +uno, y que p en uno es tres. + +00:11:22.820 --> 00:11:27.485 +Veamos un ejemplo más. Evaluémoslo en dos. Vamos + +00:11:27.485 --> 00:11:29.084 +a ver qué pasa en esta fórmula si + +00:11:29.084 --> 00:11:31.985 +yo lo pongo el dos aquí. Eso significaría + +00:11:32.445 --> 00:11:34.785 +que nos quedaría un dos por dos aquí, + +00:11:34.925 --> 00:11:37.245 +que sería un cuatro, y sumado a un + +00:11:37.245 --> 00:11:40.125 +uno nos daría un cinco. Entonces, p de + +00:11:40.125 --> 00:11:45.620 +dos sería cinco, y exactamente nos da este + +00:11:45.620 --> 00:11:49.480 +resultado. Entonces, como vemos, es posible poder expresar + +00:11:49.940 --> 00:11:56.095 +estos polinomios utilizando esta clase de vectores en + +00:11:56.095 --> 00:12:01.315 +forma de una multiplicación de esos vectores. Aquí + +00:12:02.255 --> 00:12:06.495 +llega esta clase. Ahora, la próxima clase vamos + +00:12:06.495 --> 00:12:09.589 +a hacer el primer miniproyecto. Este primer miniproyecto + +00:12:09.890 --> 00:12:12.450 +consistirá en hacer un modelo muy sencillo de + +00:12:12.450 --> 00:12:16.450 +análisis de sentimientos sobre algunos tweets. Espero que + +00:12:16.450 --> 00:12:19.010 +estés igual de emocionado que yo. Nos vemos + +00:12:19.010 --> 00:12:19.510 +allá. diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Resumen.html" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Resumen.html" new file mode 100644 index 0000000000000000000000000000000000000000..6264b8ed43b9b3b81144bc1f89b6439401730b5d --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-Resumen.html" @@ -0,0 +1,126 @@ + + + + + + + Producto Interno de Vectores en Python con NumPy + + + +
+
+

Resumen

¿Cómo realizar el producto interno de vectores en Python?

+

En el mundo de la programación y las matemáticas aplicadas, conocer cómo realizar operaciones algebraicas como el producto interno de vectores en Python es fundamental. Usar esta herramienta facilita cálculos complejos que son esenciales en campos como la inteligencia artificial y el análisis de datos. En esta clase, aprenderemos a llevar a cabo el producto interno de vectores paso a paso con la ayuda de NumPy, una biblioteca poderosa en Python.

+

¿Qué aspectos básicos debemos tener presentes?

+

Antes de adentrarnos en las operaciones en Python, es importante recordar algunos conceptos esenciales. Por ejemplo, al multiplicar el vector unitario traspuesto por otro vector se obtiene la proyección de éste sobre la dirección del vector unitario, lo que nos da un escalar. También, sumando las componentes de un vector mediante un vector uno transpuesto multiplicado por el vector original, logramos la suma total de sus componentes.

+

Además, es posible expresar la suma de los cuadrados de un vector como un producto interno, algo vital en diferentes aplicaciones matemáticas. También, conocer cómo se define un bloque de vectores y cómo aplicar el producto interno entre ellos, nos preparará para abordar problemas más complejos en el futuro.

+

¿Cómo usar NumPy para el producto interno?

+

Para realizar operaciones de producto interno de manera eficiente, utilizamos la función np.dot() de la biblioteca NumPy, la cual no necesita conversiones o transposiciones adicionales. Veamos cómo se hace:

+
import numpy as np
+
+a = np.array([1, 0, 0, 0])  # Vector e0 en R4
+b = np.array([0, 0, 1, 0])  # Vector e2 en R4
+
+producto_interno = np.dot(a, b)
+print(f'El producto interno de a y b es: {producto_interno}')
+
+

En este caso, el producto interno entre los vectores a y b es cero, lo que indica que son ortogonales.

+

¿Qué significa la ortogonalidad de vectores?

+

La ortogonalidad entre vectores significa que el producto interno entre ellos es cero. Esta propiedad es importante en la práctica, indicando que los vectores son perpendiculares en el espacio. Con NumPy, esta comprobación se realiza de manera eficiente.

+

¿Cómo definir un polinomio usando vectores en Python?

+

Otra aplicación del producto interno es expresar polinomios como una combinación lineal de vectores. Esto se logra definiendo un vector de coeficientes y evaluando el polinomio usando la multiplicación de vectores. Por ejemplo, un polinomio de la forma (P(x) = 1 + 2x) se puede expresar en Python como:

+
def P(x):
+    c = np.array([1, 2])  # Coeficientes
+    x_vector = np.array([1, x])
+    return np.dot(c, x_vector)
+
+# Evaluación del polinomio en diferentes valores
+print(P(0))  # Resultado: 1
+print(P(1))  # Resultado: 3
+print(P(2))  # Resultado: 5
+
+

¿Qué sigue después de aprender el producto interno en Python?

+

Con esta comprensión del producto interno y sus aplicaciones en Python, estás preparado para avanzar a proyectos más complejos. Próximamente abordaremos un miniproyecto que consistirá en desarrollar un sencillo modelo de análisis de sentimientos sobre tweets. Esta es una excelente manera de aplicar tus conocimientos y verlos en acción en situaciones del mundo real. ¡Sigue aprendiendo y perfeccionando tus habilidades en programación y matemáticas aplicadas!

+
+
+ + \ No newline at end of file diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-producto_interno_554a11a7-c20a-4a1c-99e8-4408610d53ae.ipynb" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-producto_interno_554a11a7-c20a-4a1c-99e8-4408610d53ae.ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..967cc0b06914e94793a8eeae06d0a77112ba6a24 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/09-producto_interno_554a11a7-c20a-4a1c-99e8-4408610d53ae.ipynb" @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. Producto Interno" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El *producto interno* (estándar) o simplemente *producto punto* de dos $n$-vectores $\\vec{a},\\vec{b}$ se define como el escalar:\n", + "\n", + "$$\n", + "<\\vec{a},\\vec{b}> = \\vec{a} \\cdot \\vec{b} = a_{0}b_{0}+a_{1}b_{1}+\\cdots+a_{n-1}b_{n-1} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}\n", + "$$\n", + "\n", + "Que es simplemente la suma del producto de sus entradas." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Por ejemplo, si $\\vec{a}=(1,2,3)$ y $\\vec{b}=(4,5,6)$ entonces el producto punto será:\n", + "\n", + "$$\n", + "\\vec{a}\\cdot\\vec{b} = (1,2,3)\\cdot (4,5,6) = 1\\cdot 4+2\\cdot 5 + 3\\cdot 6 = 4+10+18=32\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hasta ahora trabajamos de forma indiferente con *vectores columna* y *vectores renglón*, a partir de este momento **el estándar serán los vectores columna** entonces simpre que hablemos de un vector, dígamos $\\vec{a}$ entonces estaremos hablando del vector columna:\n", + "\n", + "$$\n", + "\\vec{a} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Esto también nos permite introducir una nueva operación: **la transposición**. Retomemos el vector $\\vec{a}$, denotaremos como $\\vec{a}^{T}$ al vector transpuesto de $\\vec{a}$:\n", + "\n", + "$$\n", + "\\vec{a}^{T} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}^{T} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}]\n", + "$$\n", + "\n", + "La operación de transposición nos permite cambiar de vectores columna a vectores renglón sin modificar al vector que se transponga. Notemos que es posible poder transponer un vector transpuesto_\n", + "\n", + "$$\n", + "\\left(\\vec{a}^{T}\\right)^{T} = \\left(\\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}^{T}\\right)^{T} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}]^{T} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix} = \\vec{a}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Así pues, consideremos el ejemplo anterior de los vectores $\\vec{a}$ y $\\vec{b}$. Definimos la operación $\\vec{a}^{T}\\vec{b}$ como:\n", + "\n", + "$$\n", + "\\vec{a}^{T}\\; \\vec{b} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}] \\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{n-1}\\end{bmatrix} = a_{0}b_{0} + a_{1}b_{1} + \\cdots + a_{n-1}b_{n-1} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}\n", + "$$\n", + "\n", + "Lo cual coincide con la definición del producto interno. Así pues $<\\vec{a},\\vec{b}> = \\vec{a}\\cdot \\vec{b} = \\vec{a}^{T} \\;\\vec{b} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.1 Propiedades del producto interno" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sean $\\vec{a},\\vec{b}$ dos $n$-vectores y $\\alpha$ un escalar. El producto interno entre $\\vec{a}$ y $\\vec{b}$ cumple las siguientes propiedades:\n", + "\n", + "* Conmutatividad: $\\vec{a}^{T}\\vec{b} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i} = \\displaystyle\\sum_{i=0}^{n-1} b_{i}a_{i} = \\vec{b}^{T}\\vec{a}$\n", + "\n", + "* Asociatividad con multiplicación escalar: $\\left(\\alpha \\vec{a}\\right)^{T}\\vec{b} = \\alpha\\left(\\vec{a}^{T}\\vec{b}\\right)$\n", + "\n", + "* Distribución en la adición de vectores: $\\left(\\vec{a} + \\vec{b}\\right)^{T}\\vec{c} = \\vec{a}^{T}\\vec{c} + \\vec{b}^{T}\\vec{c}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.2 Consideraciones adicionales" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Proyección**. Si $\\vec{a}$ es un $n$-vector entonces $\\hat{e}_{i}^{T}\\vec{a} = a_{i}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Suma de elementos de un vector.** $\\mathbf{1}^{T}a = a_{0}+a_{1}+\\cdots+a_{n-1}$ " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Promedio de entradas de un vector.** $(\\mathbf{1}/n)^{T}\\vec{a} = (a_{0}+a_{1}+\\cdots+a_{n-1})/n$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Suma de cuadrados de un vector.** $\\vec{a}^{T} \\;\\vec{a} = a_{0}^{2}+a_{1}^{2}+\\cdots+a_{n-1}^{2}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Producto interno de bloques de vectores**. Sean $\\vec{a},\\vec{b}$ $k$-vectores formados por concatenar los $n$-vectores $a_{i},b_{i}$:\n", + "\n", + "$$\n", + "\\vec{a}=\\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{k-1}\\end{bmatrix},\\qquad \\vec{b}=\\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{k-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Entonces el producto punto entre estos vectores va como:\n", + "\n", + "$$\n", + "\\vec{a}^{T} \\vec{b} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{k-1}]\\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{k-1}\\end{bmatrix} = a_{0}^{T}b_{0}+a_{1}^{T}b_{1} + \\cdots + a_{k-1}^{T}b_{k-1}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.3 Producto interno en Python. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sean $\\vec{a},\\vec{b}$ vectores en $\\mathbb{R}^{4}$. Diremos que los vectores son **ortogonales** o **perpendiculares** si $\\vec{a}\\cdot \\vec{b}= 0$\n", + "\n", + "Consideremos entonces $\\vec{a}=\\hat{e}_{0}$ y $\\vec{b} = \\hat{e}_{2}$. Vamos a realizar el producto punto en Python" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([1,0,0,0]) #declaramos el vector e_1\n", + "\n", + "b = np.array([0,0,1,0]) #declaramos el vector e_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para realizar el producto punto llamaremos a la función *numpy.dot*" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " = 0\n" + ] + } + ], + "source": [ + "print(' =',np.dot(a,b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "De igual manera también podemos usar el operador $@$" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " = 0\n" + ] + } + ], + "source": [ + "print(' =',a.T@b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Evaluación de polinomios**. Un polinomio de grado $n-1$ se puede expresar como $p(x) = c_{0} + c_{1}x + c_{2}x^{2} + \\cdots + c_{n-1}x^{n-1}$. Si consideramos los $n$-vectores $\\vec{c},\\vec{x}$ tales que:\n", + "\n", + "$$\n", + "\\vec{c} = \\begin{bmatrix}c_{0}\\\\ c_{1}\\\\ \\vdots \\\\ c_{n-1}\\end{bmatrix},\\qquad \\vec{x}(x) = \\begin{bmatrix}x^{0}\\\\ x^{1}\\\\ \\vdots \\\\ x^{n-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Así pues, usando estos vectores es posible expresar $p(x) = \\vec{c}^{T}\\vec{x}(x)$. Un ejemplo más concreto sería $p(x)=1+2x$, usando los vectores:\n", + "\n", + "$$\n", + "\\vec{c} = \\begin{bmatrix}1\\\\ 2 \\end{bmatrix}, \\qquad \\vec{x}(x) = \\begin{bmatrix}1\\\\ x \\end{bmatrix}\n", + "$$\n", + "\n", + "Entonces podemos escribir:\n", + "$$\n", + "p(x) = \\vec{c}^{T}\\vec{x}(x) = [1 \\; 2] \\begin{bmatrix}1\\\\ x \\end{bmatrix} = 1\\cdot 1 + 2\\cdot x = 1 + 2x\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Así pues en Python podemos escribir el polinomio como:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def p(x):\n", + " return np.array([1,2])@np.array([1,x])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "p(0) = 1\n", + "p(1) = 3\n", + "p(2) = 5\n" + ] + } + ], + "source": [ + "print('p(0) = ',p(0))\n", + "print('p(1) = ',p(1))\n", + "print('p(2) = ',p(2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.4 Ejercicios." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 1: Análisis de sentimientos de tweets.** Vamos a crear un máquina que pueda decirnos qué tan positivo, neutral o negativo son una serie de respuestas de twitter. \n", + "Las respuestas son:\n", + "> Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!\n", + "\n", + "> Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.\n", + "\n", + "> Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien.\n", + "Un saludo\n", + "\n", + "> Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "a = \"Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!\"\n", + "a = a.replace(\"!\",\"\").replace(\",\",\"\").split(\" \")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Gran',\n", + " 'mexicano',\n", + " 'y',\n", + " 'excelente',\n", + " 'en',\n", + " 'su',\n", + " 'área',\n", + " 'su',\n", + " 'muerte',\n", + " 'es',\n", + " 'una',\n", + " 'enorme',\n", + " 'perdida',\n", + " 'y',\n", + " 'debería',\n", + " 'ser',\n", + " 'luto',\n", + " 'nacional']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sí\n" + ] + } + ], + "source": [ + "if 'muerte' in a:\n", + " print(\"Sí\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora bien, no podemos sacar toda la información de los textos sino vamos a buscar cadenas (strings) específicas. Así pues vamos a construir una función de Python que cuente la cantidad de veces que aparece cierta cadena. Como ejemplo, supongamos que las palabras que vamos a contar son *muerte*, *pérdida*, *luto*, *excelente*,*gran* y *positivo*, y además esto lo queremos expresar como vector en orden respectivo, así pues el primer comentario lo podemos expresar como el siguiente vector:\n", + "$$\n", + "\\vec{w} = \\begin{bmatrix}1\\\\ 1 \\\\ 1\\\\ 1\\\\ 1 \\\\0 \\end{bmatrix}\n", + "$$\n", + "Ahora, vamos a crear otra función en la que tendremos el vector con entradas de cantidad de palabras positivas, negativas y neutras. Siguiendo con el ejemplo vamos a sumar un uno a la primer entrada si aparece alguna de las siguientes palabras *excelente*,*gran* y *positivo*, un uno en la segunda por cada vez que aparezca la palabra *pérdida* y un uno a la última entrada si aparecen las palabras *muerte* y *luto*. Así pues, el primer twett lo podemos representar como:\n", + "\n", + "$$\n", + "\\vec{s} = \\begin{bmatrix} 2 \\\\ 1 \\\\2 \\end{bmatrix}\n", + "$$\n", + "\n", + "Ahora, para ver la *calidad* del resultado que tendremos para un twett conviene calcular el promedio de las entradas de un vector de palabras\n", + "$$avg(\\vec{w}) = (\\mathbf{1}/n)^{T}\\vec{w}$$\n", + "Y después calcularás el promedio del sentimiento de cada tweet $avg(\\vec{s})$ y de igual manera el *score sentimental* que se define como \n", + "$$score(\\vec{s}) = [1\\; 0\\; -1] \\begin{bmatrix} s_{0} \\\\ s_{1} \\\\s_{2} \\end{bmatrix}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Leyendo los tuits decide el conjunto mínimo de palabras que vas a contar en todos los tuits, solamente deberás hacer una función para contar palabras para todos los tuits, no hagas un función por enunciado. Según tu esquema reponde lo siguiente:\n", + "\n", + "* ¿Qué tuit es más positivo?\n", + "\n", + "* ¿Qué tuit es más negativo?\n", + "\n", + "* ¿Cuál es tu calidad promedio?\n", + "\n", + "* ¿Cómo interpretas $avg(\\vec{s})$ y $score(\\vec{s})$?\n", + "\n", + "* ¿Cómo relacionas la calidad con $score(\\vec{s})$ y $avg(\\vec{s})$?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-An\303\241lisis de Sentimientos de Tweets con Vectores de Palabras.mp4" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-An\303\241lisis de Sentimientos de Tweets con Vectores de Palabras.mp4" new file mode 100644 index 0000000000000000000000000000000000000000..d350f3c1770d34e498d2d7c887bff63d671c6d4d --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-An\303\241lisis de Sentimientos de Tweets con Vectores de Palabras.mp4" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0201a390f7fb810abbee5722892a354e88e69b41f15119ce0c983477abbb8c68 +size 142527775 diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-An\303\241lisis de Sentimientos de Tweets con Vectores de Palabras.vtt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-An\303\241lisis de Sentimientos de Tweets con Vectores de Palabras.vtt" new file mode 100644 index 0000000000000000000000000000000000000000..197a922046eb75339e77b1e95e4481932801a60a --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-An\303\241lisis de Sentimientos de Tweets con Vectores de Palabras.vtt" @@ -0,0 +1,787 @@ +WEBVTT + +00:00:03.439 --> 00:00:07.520 +Hola, te doy la bienvenida de nuevo. Estoy + +00:00:07.520 --> 00:00:10.719 +muy emocionado de que estés aquí. El camino + +00:00:10.719 --> 00:00:13.840 +fue largo y es un poco más largo + +00:00:13.840 --> 00:00:16.785 +todavía, pero en esta clase vas a ver + +00:00:16.785 --> 00:00:18.785 +lo que tienes ahora ya y de lo + +00:00:18.785 --> 00:00:21.605 +que eres capaz de hacer con las habilidades + +00:00:21.665 --> 00:00:25.345 +que has adquirido hasta ahora. Lo que vamos + +00:00:25.345 --> 00:00:27.205 +a hacer va a ser una pequeña máquina + +00:00:27.585 --> 00:00:32.440 +de análisis de sentimiento de unos tweets. No + +00:00:32.440 --> 00:00:35.320 +vamos a hacer procesamiento de lenguaje natural, vamos + +00:00:35.320 --> 00:00:37.240 +a hacer algo más rústico, algo un poco + +00:00:37.240 --> 00:00:39.980 +más sencillo, en donde vamos a extraer características + +00:00:40.280 --> 00:00:42.680 +de los enunciados y a esas las vamos + +00:00:42.680 --> 00:00:45.525 +a calificar como positivas o negativas, y al + +00:00:45.525 --> 00:00:47.985 +final nos va a dar eso, un score + +00:00:48.125 --> 00:00:50.625 +de qué tan positivo o negativo es el + +00:00:50.645 --> 00:00:52.765 +sentimiento, al mismo tiempo de que vamos a + +00:00:52.765 --> 00:00:57.725 +analizar la calidad de de nuestro análisis. Sin + +00:00:57.725 --> 00:01:03.680 +más, vamos al notebook. El problema que vamos + +00:01:03.680 --> 00:01:05.920 +a tratar ahora es el análisis de sentimientos + +00:01:05.920 --> 00:01:07.280 +de tweets. Lo que vamos a hacer va + +00:01:07.280 --> 00:01:08.960 +a ser crear una pequeña máquina que puede + +00:01:08.960 --> 00:01:11.520 +decirnos qué tan positivo, neutral o negativo son + +00:01:11.520 --> 00:01:14.125 +una serie de respuestas de Twitter. Las respuestas + +00:01:14.125 --> 00:01:16.145 +de Twitter que vamos a analizar son estas. + +00:01:16.365 --> 00:01:18.605 +Gran mexicano y excelente en su área, su + +00:01:18.605 --> 00:01:20.685 +muerte es una enorme pérdida y breve salud + +00:01:20.685 --> 00:01:24.045 +nacional. Vaya señora, qué bueno que se asesora + +00:01:24.045 --> 00:01:26.605 +por alguien inteligente, no por el ignorante del + +00:01:26.605 --> 00:01:29.490 +gato. Se me ocurre, y sin ver todos + +00:01:29.490 --> 00:01:31.810 +los videos de Platzi, que me informéis por + +00:01:31.810 --> 00:01:34.610 +dónde empiezo. Entiendo que os tendría que decir + +00:01:34.610 --> 00:01:37.510 +quién soy y qué quiero. Vamos a conocerme + +00:01:37.970 --> 00:01:42.095 +para asesorarme bien. Un saludo. Soy docente universitario, + +00:01:42.635 --> 00:01:45.115 +estoy intentando preparar mis clases en modo platzi + +00:01:45.115 --> 00:01:48.555 +bien didáctico, le llamo modo noticiero. Descargué una + +00:01:48.555 --> 00:01:51.595 +plataforma gratuita de grabación y transmisiones de video, + +00:01:51.595 --> 00:01:55.750 +se llama OBS Studio. Bueno, la sigo remando + +00:01:55.970 --> 00:01:58.630 +con sus funciones, pero sé que saldrá algo. + +00:02:00.850 --> 00:02:03.110 +De estos hay cosas que me gustaría señalar, + +00:02:03.570 --> 00:02:05.970 +por ejemplo, no se abre ni se cierran + +00:02:05.970 --> 00:02:08.925 +símbolos de exclamación, tampoco hay un punto que + +00:02:08.925 --> 00:02:11.945 +nos determine en dónde se acaba la oración. + +00:02:12.285 --> 00:02:15.085 +En este, por ejemplo, no hay ningún símbolo + +00:02:15.085 --> 00:02:19.085 +de puntuación. En este de aquí se están + +00:02:19.085 --> 00:02:22.820 +utilizando formas verbales o conjugaciones que no utilizamos + +00:02:22.820 --> 00:02:30.420 +regularmente en Latinoamérica, como informéis y os. De + +00:02:30.420 --> 00:02:33.560 +igual manera, no hay un punto al final, + +00:02:34.175 --> 00:02:36.195 +además de que hay una serie de puntos, + +00:02:37.375 --> 00:02:40.115 +y en la esta última, por ejemplo, aquí, + +00:02:40.255 --> 00:02:43.455 +no hay un espacio, además de que no + +00:02:43.455 --> 00:02:45.535 +está bien la apertura de este símbolo de + +00:02:45.535 --> 00:02:49.250 +exclamación. También tenemos la introducción de paréntesis y + +00:02:49.250 --> 00:02:54.690 +comas. Ahora, lo que vamos a hacer no + +00:02:54.690 --> 00:02:57.030 +es sacar toda la información de los textos, + +00:02:57.490 --> 00:03:01.715 +sino vamos a buscar cadenas específicas. Vamos a + +00:03:01.715 --> 00:03:04.755 +pensar cada uno de esos enunciados como una + +00:03:04.755 --> 00:03:07.575 +cadena y vamos a sacar características de ellas. + +00:03:08.035 --> 00:03:11.815 +Por ejemplo, supongamos que del primer enunciado nosotros + +00:03:11.875 --> 00:03:16.090 +queremos extraer información, pero solamente las palabras que + +00:03:16.090 --> 00:03:20.170 +nos interesan son muerte, pérdida, luto, excelente gran, + +00:03:20.170 --> 00:03:24.730 +positivo, y además esto lo queremos expresar como + +00:03:24.730 --> 00:03:30.485 +un vector en orden respectivo. ¿Cómo vamos a + +00:03:30.485 --> 00:03:34.325 +hacer esto? Bueno, primero, vamos a tomar cada + +00:03:34.325 --> 00:03:39.765 +uno de estos elementos como una cadena. Este, + +00:03:39.765 --> 00:03:49.049 +por ejemplo. Ahora, podemos eliminar algunos elementos, como + +00:03:49.430 --> 00:03:55.269 +los símbolos de exclamación y las comas, usando + +00:03:55.269 --> 00:03:59.785 +la función replace. Lo que queremos eliminar es + +00:03:59.785 --> 00:04:02.345 +este y lo vamos a reemplazar con un + +00:04:02.345 --> 00:04:06.105 +vacío. De igual manera, queremos reemplazar las comas + +00:04:06.105 --> 00:04:10.285 +que hayan quedado y las vamos a reemplazar + +00:04:10.425 --> 00:04:14.380 +con un vacío. Por último, vamos a partir + +00:04:14.380 --> 00:04:16.899 +este enunciado usando la función split y nos + +00:04:16.899 --> 00:04:18.660 +va a crear un vector de todas las + +00:04:18.660 --> 00:04:21.700 +palabras, y lo vamos a partir por los + +00:04:21.700 --> 00:04:28.485 +espacios. Ejecutamos la celda y veamos el resultado + +00:04:28.485 --> 00:04:31.625 +que obtenemos. Como vemos, haya es un vector + +00:04:32.245 --> 00:04:36.885 +de todas las palabras que están en este + +00:04:36.885 --> 00:04:39.925 +enunciado, y además ya no hay comas ni + +00:04:39.925 --> 00:04:43.520 +hay signos de exclamación. En el caso de + +00:04:43.740 --> 00:04:48.479 +este, tendrías que introducir algo para poder lidiar + +00:04:48.780 --> 00:04:53.900 +justamente con este espacio, por ejemplo. Ahora, lo + +00:04:53.900 --> 00:04:56.719 +que vamos a hacer es buscar esas palabras + +00:04:58.545 --> 00:05:01.825 +aquí, y si esas palabras están aquí, en + +00:05:01.825 --> 00:05:05.825 +este vector w los vamos a denotar como + +00:05:05.825 --> 00:05:08.465 +el número de veces que estas aparezca. Es + +00:05:08.465 --> 00:05:12.965 +decir, si muerte apareciera una vez en este, + +00:05:13.710 --> 00:05:16.690 +vamos a poner un uno. Podríamos hacer eso, + +00:05:18.030 --> 00:05:27.705 +entonces podríamos hacer if muerte. In a, entonces, + +00:05:27.705 --> 00:05:33.225 +vamos a imprimir aquí un sí. Sí, sí + +00:05:33.225 --> 00:05:37.465 +está. Entonces, aquí iría un uno. Ahora, aquí + +00:05:37.465 --> 00:05:39.705 +no nos tiene que poner únicamente un uno, + +00:05:39.705 --> 00:05:42.660 +si aparece una vez, debería aparecer un uno. + +00:05:42.660 --> 00:05:45.440 +Si aparece dos veces, debería aparecer un dos. + +00:05:45.500 --> 00:05:47.660 +Un tres, tres veces, y así de manera + +00:05:47.660 --> 00:05:51.580 +consecutiva. Si muerde esta, entonces, aquí va un + +00:05:51.580 --> 00:05:53.835 +se suma un uno a esta primera entrada. + +00:05:54.074 --> 00:05:56.155 +Si perdí de esta, se suma un uno + +00:05:56.155 --> 00:05:58.315 +a esta entrada a la segunda, bruto a + +00:05:58.315 --> 00:06:00.715 +la tercera, excelente a la cuarta, gran a + +00:06:00.715 --> 00:06:05.275 +la quinta y positivo a la sexta. Vamos + +00:06:05.275 --> 00:06:07.115 +a ver un dibujo para poder entender esto + +00:06:07.115 --> 00:06:10.260 +de mejor manera. Vamos a hacer un ejemplo + +00:06:10.260 --> 00:06:13.320 +mucho más pequeño. Vamos a suponer que nosotros + +00:06:14.100 --> 00:06:17.940 +estamos extrayendo la letra y, y además, las + +00:06:17.940 --> 00:06:22.625 +palabras mexicano y excelente. Como vemos, la letra + +00:06:22.625 --> 00:06:26.245 +y está una vez aquí y también está + +00:06:26.305 --> 00:06:29.505 +una vez aquí, por eso la contribución de + +00:06:29.505 --> 00:06:32.465 +esta y de esta nos da un dos + +00:06:32.465 --> 00:06:35.190 +a la primera entrada, porque en la primera + +00:06:35.190 --> 00:06:37.830 +entrada estamos denotando la cantidad de veces que + +00:06:37.830 --> 00:06:40.790 +aparece la letra y. En la segunda entrada + +00:06:40.790 --> 00:06:42.710 +vamos a denotar la cantidad de veces que + +00:06:42.710 --> 00:06:45.510 +aparece la palabra mexicano, y en todo este + +00:06:45.510 --> 00:06:49.350 +enunciado solamente aparece una vez, entonces va un + +00:06:49.350 --> 00:06:53.165 +uno. En el caso de la palabra excelente, + +00:06:53.165 --> 00:06:55.905 +como también la queremos contar aquí, queremos denotarla + +00:06:55.965 --> 00:06:59.485 +en este vector, solamente aparece una vez. Por + +00:06:59.485 --> 00:07:03.120 +ello, solamente se le cuenta una vez. Ahora, + +00:07:03.180 --> 00:07:05.820 +si en lugar de eso quisiéramos extraer la + +00:07:05.820 --> 00:07:10.080 +cantidad de veces que aparece la letra l, + +00:07:11.500 --> 00:07:13.900 +aquí la letra y, aquí la letra l + +00:07:13.900 --> 00:07:18.815 +y aquí la palabra excelente, el vector que + +00:07:18.815 --> 00:07:22.095 +tendremos es el siguiente. La y ya vimos + +00:07:22.095 --> 00:07:24.655 +que aparece dos veces. En el caso de + +00:07:24.655 --> 00:07:28.755 +la l está una vez aquí, y está + +00:07:28.895 --> 00:07:32.905 +otra vez acá, y otra vez acá. Entonces, + +00:07:32.977 --> 00:07:35.480 +aquí vendría un tres en lugar de un + +00:07:35.480 --> 00:07:43.580 +uno. Tres. Y la letra excelente sigue apareciendo + +00:07:44.280 --> 00:07:46.625 +solamente una vez, entonces, por eso solo está + +00:07:46.625 --> 00:07:49.105 +una vez aquí. La realidad es que nos + +00:07:49.105 --> 00:07:52.465 +conviene empezar a analizar, en lugar de letras, + +00:07:52.465 --> 00:07:56.145 +palabras, porque las palabras tienen muchísimo más contexto + +00:07:56.145 --> 00:08:00.910 +que estar analizando letras individuales. Regresemos al notebook. + +00:08:05.930 --> 00:08:09.370 +Ahora, ya que entendimos cómo construir nuestro vector + +00:08:09.370 --> 00:08:12.384 +de conteo de palabras, nuestro vector w, vamos + +00:08:12.384 --> 00:08:15.685 +a construir un nuevo vector. Este nuevo vector + +00:08:15.745 --> 00:08:18.705 +será el vector de sentimientos, en donde en + +00:08:18.705 --> 00:08:21.604 +la primera entrada estará la cantidad de palabras + +00:08:21.664 --> 00:08:24.465 +positivas que hay, en la segunda la cantidad + +00:08:24.465 --> 00:08:26.460 +de palabras neutras que hay, y en la + +00:08:26.460 --> 00:08:28.740 +tercera, la cantidad de palabras negativas que hay. + +00:08:28.740 --> 00:08:33.280 +Por ejemplo, si nosotros decimos que las palabras + +00:08:33.500 --> 00:08:37.740 +excelente, gran y positivo son palabras positivas, al + +00:08:37.740 --> 00:08:42.115 +igual que pérdida, una palabra neutra, y muerte + +00:08:42.115 --> 00:08:46.595 +y luto, palabras negativas, el primer tweet, este + +00:08:46.595 --> 00:08:51.955 +de aquí, lo podríamos representar como este vector + +00:08:51.955 --> 00:08:55.710 +de aquí. Entonces, vamos a dibujar un poco + +00:08:55.710 --> 00:09:03.870 +para entenderlo mejor. Si nosotros suponemos que la + +00:09:03.870 --> 00:09:09.685 +aparición de la palabra gran mexicano excelente y + +00:09:09.685 --> 00:09:14.805 +nacional son palabras positivas, entonces tendríamos en la + +00:09:14.805 --> 00:09:18.885 +primera entrada un uno más un dos más + +00:09:18.885 --> 00:09:22.585 +un tres más un cuatro. Entonces estas palabras + +00:09:22.725 --> 00:09:25.709 +aportan hacia un cuatro en la primera entrada. + +00:09:25.709 --> 00:09:30.110 +En la segunda entrada podríamos empezar a contar + +00:09:30.110 --> 00:09:38.175 +las palabras pérdida y la palabra enorme. Entonces, + +00:09:38.175 --> 00:09:40.735 +fíjense que no estamos dando el contexto de + +00:09:40.735 --> 00:09:44.334 +pérdida y enorme, simplemente estamos buscando que sea + +00:09:44.334 --> 00:09:47.375 +la palabra enorme y pérdida. Nosotros sabemos que + +00:09:47.375 --> 00:09:52.710 +esta combinación de palabras puede denotar algo negativo, + +00:09:52.710 --> 00:09:55.290 +sin embargo, vamos a pensar que de manera + +00:09:55.430 --> 00:09:58.730 +individual son palabras neutras, entonces estas dos aportan + +00:09:58.870 --> 00:10:02.535 +un dos aquí. Y por último, vamos a + +00:10:02.535 --> 00:10:05.574 +pensar que las palabras muerte y luto son + +00:10:05.574 --> 00:10:09.495 +palabras negativas, entonces estas están aportando un dos + +00:10:09.495 --> 00:10:12.694 +aquí. Así tenemos representado en un vector de + +00:10:12.694 --> 00:10:18.030 +sentimientos todo este enunciado. Regresemos al notebook. Ahora + +00:10:18.030 --> 00:10:21.070 +bien, ya que ya entendimos cómo construir nuestros + +00:10:21.070 --> 00:10:23.810 +vectores de palabras y nuestros vectores de sentimientos, + +00:10:24.190 --> 00:10:26.270 +lo que hay que hacer ahora es analizar + +00:10:26.270 --> 00:10:29.550 +la calidad del resultado que tenemos. Para eso, + +00:10:29.550 --> 00:10:31.945 +lo que vamos a hacer va a ser + +00:10:31.945 --> 00:10:35.065 +tomar el vector w y calcular el promedio + +00:10:35.065 --> 00:10:40.925 +del vector w. Pensémoslo así, si nuestro vector + +00:10:41.305 --> 00:10:43.225 +w es un n vector y todas las + +00:10:43.225 --> 00:10:47.400 +entradas son uno, la suma sería n, entonces + +00:10:47.400 --> 00:10:52.360 +el promedio sería uno. En el caso de + +00:10:52.360 --> 00:10:55.320 +que sea menor que uno, este número de + +00:10:55.320 --> 00:10:59.915 +aquí sería menor que uno. Podría ser cero + +00:10:59.915 --> 00:11:02.875 +punto nueve, cero punto ocho, cero punto siete, + +00:11:02.875 --> 00:11:06.714 +cero punto tres. Y eso nos daría la + +00:11:06.714 --> 00:11:10.495 +calidad de palabras o la cantidad de palabras + +00:11:10.940 --> 00:11:14.140 +que están apareciendo de nuestro análisis o de + +00:11:14.140 --> 00:11:16.880 +las palabras que nos interesan en los enunciados. + +00:11:18.860 --> 00:11:23.120 +Ahora bien, si hay muchas palabras y coinciden + +00:11:23.339 --> 00:11:27.145 +muchas veces, este promedio sería mayor que uno. + +00:11:27.685 --> 00:11:29.705 +Si es mayor que uno, nos está indicando + +00:11:29.765 --> 00:11:33.365 +que tenemos suficiencia de palabras. En el uno + +00:11:33.365 --> 00:11:36.325 +también nos indicaría un buen resultado. Si es + +00:11:36.325 --> 00:11:39.225 +menor que uno, es I mayor que cero + +00:11:39.285 --> 00:11:41.800 +punto cinco nos está indicando que es un + +00:11:41.800 --> 00:11:45.000 +resultado del que podríamos tener alguna incertidumbre, y + +00:11:45.000 --> 00:11:47.400 +la calidad de ese resultado, así le vamos + +00:11:47.400 --> 00:11:49.400 +a llamar a esa medida, se hará este + +00:11:49.400 --> 00:11:52.300 +promedio, y si es menor que cero punto + +00:11:52.600 --> 00:11:54.440 +cinco, vamos a decir que la calidad es + +00:11:54.440 --> 00:11:57.394 +mala. Es decir, que ni siquiera la mitad + +00:11:57.394 --> 00:12:00.695 +de las palabras que queríamos analizar estaban apareciendo + +00:12:00.755 --> 00:12:03.074 +en los enunciados o en el enunciado que + +00:12:03.074 --> 00:12:08.774 +analizamos. Ahora bien, después de calcular el promedio + +00:12:10.130 --> 00:12:13.010 +de cada uno de esos tweets que nos + +00:12:13.010 --> 00:12:17.970 +dará la calidad, vamos a calcular el sentimiento + +00:12:17.970 --> 00:12:20.930 +o el score sentimental de cada uno de + +00:12:20.930 --> 00:12:24.165 +los enunciados. Para eso vamos a recurrir a + +00:12:24.165 --> 00:12:27.205 +la función, a esta relación de aquí score, + +00:12:27.205 --> 00:12:29.765 +en donde le vamos a meter nuestro vector + +00:12:29.765 --> 00:12:33.525 +de sentimientos s. Notemos que este vector es + +00:12:33.525 --> 00:12:36.300 +diferente, al igual que este vector, para cada + +00:12:36.300 --> 00:12:40.540 +uno de los enunciados que tenemos aquí. Así, + +00:12:40.540 --> 00:12:46.400 +pues, notemos que en el score solamente cuentan + +00:12:46.940 --> 00:12:50.524 +la cantidad de puntos que tenemos o de + +00:12:50.524 --> 00:12:53.644 +de coincidencias de palabras positivas y la cantidad + +00:12:53.644 --> 00:13:00.764 +de palabras negativas. Tu tarea en este proyecto + +00:13:00.764 --> 00:13:03.220 +va a ser leer los tweets y encontrar + +00:13:03.220 --> 00:13:06.280 +el conjunto mínimo de palabras, es decir, el + +00:13:07.300 --> 00:13:09.300 +conjunto que tú vas a poder hacer para + +00:13:09.300 --> 00:13:13.140 +construir este vector w que tenga palabras que + +00:13:13.140 --> 00:13:16.680 +sean transversales a todos los enunciados, a todas + +00:13:16.900 --> 00:13:22.454 +esos tweets. Y al mismo tiempo, deberás de + +00:13:22.454 --> 00:13:25.655 +construir solamente una función para construir tanto esta + +00:13:25.655 --> 00:13:30.535 +s como esta w. No hay que hacer + +00:13:30.535 --> 00:13:32.910 +una función por enunciado, tiene que ser una + +00:13:32.910 --> 00:13:37.950 +función general para todos esos tweets. Ahora, según + +00:13:37.950 --> 00:13:40.430 +el esquema que tú elijas y que tú + +00:13:40.430 --> 00:13:44.190 +escojas, tendrás que responder estas preguntas. ¿Qué tweet + +00:13:44.190 --> 00:13:46.750 +es más positivo? ¿Cuál es el tweet más + +00:13:46.750 --> 00:13:51.465 +negativo? Cuál es la calidad promedio de tus + +00:13:53.125 --> 00:13:56.245 +de tus análisis, notemos que cada uno de + +00:13:56.245 --> 00:13:59.225 +estos enunciados va a tener una calidad asociada. + +00:13:59.525 --> 00:14:04.070 +Entonces, podemos construir un cuatro vector, y este + +00:14:04.070 --> 00:14:08.870 +cuatro vector lo podemos promediar también, sacando el + +00:14:08.870 --> 00:14:12.470 +promedio de los promedios, es decir, el promedio + +00:14:12.470 --> 00:14:15.670 +de las calidades, obtendremos la calidad promedio de + +00:14:15.670 --> 00:14:18.245 +nuestro análisis. Ese es el número que me + +00:14:18.245 --> 00:14:21.205 +tendrás que dar. ¿Es una buena calidad? ¿Es + +00:14:21.205 --> 00:14:26.805 +una mala calidad? Ahora, ¿cómo interpretas tú el + +00:14:26.805 --> 00:14:31.410 +score s? ¿Cómo interpretamos este número de aquí? + +00:14:31.889 --> 00:14:35.730 +¿Y cómo lo interpretaríamos contra el promedio de + +00:14:35.730 --> 00:14:39.649 +estas entradas? Recordemos que en el score s + +00:14:39.649 --> 00:14:43.250 +solamente cuentan la cantidad de puntos positivos y + +00:14:43.250 --> 00:14:47.145 +negativos. Notemos que si solamente tenemos palabras neutras, + +00:14:47.285 --> 00:14:50.165 +este score sería cero, mientras que si tenemos + +00:14:50.165 --> 00:14:53.365 +un promedio, si estas son cero, el promedio + +00:14:53.365 --> 00:14:57.205 +no sería cero, sino sería tres entre este + +00:14:57.205 --> 00:15:00.690 +número s uno. ¿Cuál es la diferencia entre + +00:15:00.910 --> 00:15:03.410 +el promedio de s y el score s? + +00:15:03.790 --> 00:15:08.209 +¿Cómo los interpretas? Y, por último, ¿cómo relacionas + +00:15:08.430 --> 00:15:10.750 +la calidad con tu score y con tu + +00:15:10.750 --> 00:15:15.005 +promedio? Es decir, ¿una calidad baja te lleva + +00:15:15.005 --> 00:15:17.805 +a un score distinto? ¿Te lleva a un + +00:15:17.805 --> 00:15:23.565 +promedio distinto? Te invito también a que juegues + +00:15:23.565 --> 00:15:25.665 +con la cantidad de palabras que estás analizando + +00:15:25.725 --> 00:15:28.770 +para poder responder la última pregunta. Aquí quita + +00:15:28.770 --> 00:15:31.330 +palabras o añade palabras, eso va a hacer + +00:15:31.330 --> 00:15:34.050 +que tu calidad suba o baje. ¿Cómo varían + +00:15:34.050 --> 00:15:38.290 +esos scores? ¿Tienes algún umbral en el que + +00:15:38.290 --> 00:15:42.945 +ya no varían? Te invito a que dejes + +00:15:42.945 --> 00:15:47.825 +todas estas respuestas en los comentarios. Esta fue + +00:15:47.825 --> 00:15:53.084 +la presentación del primer proyecto. Cualquier duda que + +00:15:53.084 --> 00:15:56.045 +tengas, escríbela en los comentarios. Yo estoy ansioso + +00:15:56.045 --> 00:15:58.524 +de poder ver sus resultados. Nos vemos la + +00:15:58.524 --> 00:15:59.345 +próxima clase. diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-Lecturas recomendadas.txt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-Lecturas recomendadas.txt" new file mode 100644 index 0000000000000000000000000000000000000000..2760ca86f92c5f7fdb9d136373b98526474eb71c --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-Lecturas recomendadas.txt" @@ -0,0 +1 @@ +https://colab.research.google.com/drive/1zLgEfmILRmfGXpHHsH5e6gYc9kM7qT5S?usp=sharing diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-Resumen.html" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-Resumen.html" new file mode 100644 index 0000000000000000000000000000000000000000..18ff529d0ba2eea2e71248040c219a5261277f04 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-Resumen.html" @@ -0,0 +1,148 @@ + + + + + + + Análisis de Sentimientos de Tweets con Vectores de Palabras + + + +
+
+

Resumen

¿Cómo desarrollar un análisis de sentimientos de tweets?

+

El análisis de sentimientos es una herramienta poderosa para comprender el tono y las emociones detrás de los textos y, en este caso, de los tweets. Aunque no realizaremos un procesamiento avanzado del lenguaje natural, aprenderás a detectar signos de positividad, neutralidad o negatividad mediante un enfoque más sencillo, observando características específicas de los enunciados. Vamos a construir una máquina de análisis y analizar la calidad de nuestro trabajo.

+

¿Cómo manejamos los datos textuales?

+

Comencemos por considerar cada tweet como una cadena que podemos analizar. Queremos eliminar elementos no deseados y enfocar nuestra atención en términos específicos que denoten el sentimiento. Utilizaremos funciones básicas para manejar cadenas de texto:

+
    +
  • replace(): Útil para eliminar símbolos como signos de exclamación o comas.
    • +
  • split(): Divide la cadena en un vector de palabras usando espacios como separadores.
    • +
+

Estos pasos nos permiten limpiar los textos para un análisis más preciso.

+

¿Cómo identificamos y cuantificamos las palabras clave?

+

Para obtener un vector de características, buscaremos en nuestros tweets palabras de interés, tales como "muerte", "pérdida", "excelente" o "gran":

+
# Ejemplo en Python
+emoticones = ['<:)','<3']
+
+# nuestra función es la siguiente
+def palabra_etiqueta(texto, etiquetas, emoticones):
+    puntuacion = 0
+    palabra = texto.split()
+    for e in emoticones:
+        if e in texto:
+            puntuacion += 1
+    for w in palabra:
+        if w in etiquetas:
+            puntuacion += 1
+        else:
+            puntuacion -= 1
+    return puntuacion
+
+

Con esto, creamos un vector w que refleja la ocurrencia de estas palabras en cada tweet. Si una palabra aparece varias veces, su conteo se incrementa.

+

¿Cómo evaluamos el sentimiento?

+

Construimos un vector de sentimientos para clasificar las palabras en positivas, neutras y negativas:

+
    +
  • Positivas: "excelente", "gran", "positivo".
    • +
  • Neutras: "pérdida".
    • +
  • Negativas: "muerte", "luto".
    • +
+

Estos registros nos ayudan a determinar un score sentimental que compara las palabras positivas y negativas.

+

¿Qué se mide y cómo lo interpretamos?

+

Para evaluar la calidad de nuestro análisis, calculamos el promedio del vector w. Esto considera cuántas veces aparecen las palabras que nos interesan:

+
    +
  • Si el promedio es 1: Buen resultado.
    • +
  • Mayor a 1: Alta frecuencia de coincidencias.
    • +
  • Menor de 1 y mayor de 0.5: Resultados más inciertos.
    • +
  • Menor de 0.5: Calidad deficiente.
    • +
+

Este análisis de calidad nos muestra la efectividad del análisis de sentimientos.

+

¿Cómo contestar las preguntas críticas del análisis?

+

Al final del ejercicio, deberás responder algunas preguntas clave:

+
    +
  1. ¿Qué tweet es el más positivo o el más negativo?
    2. +
  2. ¿Cuál es la calidad promedio de tus análisis?
    3. +
  3. ¿Qué relación hay entre la calidad y el score?
    4. +
+

Experimentos adicionales podrían incluir jugar con diferentes palabras clave para afinar la calidad y el score de los resultados. Cada ajuste y reevaluación te permitirá mejorar tus habilidades de análisis y entender mejor la influencia de las palabras en la percepción emocional de los textos.

+
+
+ + \ No newline at end of file diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-producto_interno_d76312cb-c13c-4a95-9c40-827332ec9fef.ipynb" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-producto_interno_d76312cb-c13c-4a95-9c40-827332ec9fef.ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..967cc0b06914e94793a8eeae06d0a77112ba6a24 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-producto_interno_d76312cb-c13c-4a95-9c40-827332ec9fef.ipynb" @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. Producto Interno" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "El *producto interno* (estándar) o simplemente *producto punto* de dos $n$-vectores $\\vec{a},\\vec{b}$ se define como el escalar:\n", + "\n", + "$$\n", + "<\\vec{a},\\vec{b}> = \\vec{a} \\cdot \\vec{b} = a_{0}b_{0}+a_{1}b_{1}+\\cdots+a_{n-1}b_{n-1} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}\n", + "$$\n", + "\n", + "Que es simplemente la suma del producto de sus entradas." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Por ejemplo, si $\\vec{a}=(1,2,3)$ y $\\vec{b}=(4,5,6)$ entonces el producto punto será:\n", + "\n", + "$$\n", + "\\vec{a}\\cdot\\vec{b} = (1,2,3)\\cdot (4,5,6) = 1\\cdot 4+2\\cdot 5 + 3\\cdot 6 = 4+10+18=32\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hasta ahora trabajamos de forma indiferente con *vectores columna* y *vectores renglón*, a partir de este momento **el estándar serán los vectores columna** entonces simpre que hablemos de un vector, dígamos $\\vec{a}$ entonces estaremos hablando del vector columna:\n", + "\n", + "$$\n", + "\\vec{a} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Esto también nos permite introducir una nueva operación: **la transposición**. Retomemos el vector $\\vec{a}$, denotaremos como $\\vec{a}^{T}$ al vector transpuesto de $\\vec{a}$:\n", + "\n", + "$$\n", + "\\vec{a}^{T} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}^{T} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}]\n", + "$$\n", + "\n", + "La operación de transposición nos permite cambiar de vectores columna a vectores renglón sin modificar al vector que se transponga. Notemos que es posible poder transponer un vector transpuesto_\n", + "\n", + "$$\n", + "\\left(\\vec{a}^{T}\\right)^{T} = \\left(\\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix}^{T}\\right)^{T} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}]^{T} = \\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{n-1}\\end{bmatrix} = \\vec{a}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Así pues, consideremos el ejemplo anterior de los vectores $\\vec{a}$ y $\\vec{b}$. Definimos la operación $\\vec{a}^{T}\\vec{b}$ como:\n", + "\n", + "$$\n", + "\\vec{a}^{T}\\; \\vec{b} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{n-1}] \\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{n-1}\\end{bmatrix} = a_{0}b_{0} + a_{1}b_{1} + \\cdots + a_{n-1}b_{n-1} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}\n", + "$$\n", + "\n", + "Lo cual coincide con la definición del producto interno. Así pues $<\\vec{a},\\vec{b}> = \\vec{a}\\cdot \\vec{b} = \\vec{a}^{T} \\;\\vec{b} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.1 Propiedades del producto interno" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sean $\\vec{a},\\vec{b}$ dos $n$-vectores y $\\alpha$ un escalar. El producto interno entre $\\vec{a}$ y $\\vec{b}$ cumple las siguientes propiedades:\n", + "\n", + "* Conmutatividad: $\\vec{a}^{T}\\vec{b} = \\displaystyle\\sum_{i=0}^{n-1} a_{i}b_{i} = \\displaystyle\\sum_{i=0}^{n-1} b_{i}a_{i} = \\vec{b}^{T}\\vec{a}$\n", + "\n", + "* Asociatividad con multiplicación escalar: $\\left(\\alpha \\vec{a}\\right)^{T}\\vec{b} = \\alpha\\left(\\vec{a}^{T}\\vec{b}\\right)$\n", + "\n", + "* Distribución en la adición de vectores: $\\left(\\vec{a} + \\vec{b}\\right)^{T}\\vec{c} = \\vec{a}^{T}\\vec{c} + \\vec{b}^{T}\\vec{c}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.2 Consideraciones adicionales" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Proyección**. Si $\\vec{a}$ es un $n$-vector entonces $\\hat{e}_{i}^{T}\\vec{a} = a_{i}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Suma de elementos de un vector.** $\\mathbf{1}^{T}a = a_{0}+a_{1}+\\cdots+a_{n-1}$ " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Promedio de entradas de un vector.** $(\\mathbf{1}/n)^{T}\\vec{a} = (a_{0}+a_{1}+\\cdots+a_{n-1})/n$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Suma de cuadrados de un vector.** $\\vec{a}^{T} \\;\\vec{a} = a_{0}^{2}+a_{1}^{2}+\\cdots+a_{n-1}^{2}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Producto interno de bloques de vectores**. Sean $\\vec{a},\\vec{b}$ $k$-vectores formados por concatenar los $n$-vectores $a_{i},b_{i}$:\n", + "\n", + "$$\n", + "\\vec{a}=\\begin{bmatrix}a_{0}\\\\ a_{1}\\\\ \\vdots \\\\ a_{k-1}\\end{bmatrix},\\qquad \\vec{b}=\\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{k-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Entonces el producto punto entre estos vectores va como:\n", + "\n", + "$$\n", + "\\vec{a}^{T} \\vec{b} = [a_{0}\\; a_{1}\\; \\cdots \\; a_{k-1}]\\begin{bmatrix}b_{0}\\\\ b_{1}\\\\ \\vdots \\\\ b_{k-1}\\end{bmatrix} = a_{0}^{T}b_{0}+a_{1}^{T}b_{1} + \\cdots + a_{k-1}^{T}b_{k-1}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.3 Producto interno en Python. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sean $\\vec{a},\\vec{b}$ vectores en $\\mathbb{R}^{4}$. Diremos que los vectores son **ortogonales** o **perpendiculares** si $\\vec{a}\\cdot \\vec{b}= 0$\n", + "\n", + "Consideremos entonces $\\vec{a}=\\hat{e}_{0}$ y $\\vec{b} = \\hat{e}_{2}$. Vamos a realizar el producto punto en Python" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([1,0,0,0]) #declaramos el vector e_1\n", + "\n", + "b = np.array([0,0,1,0]) #declaramos el vector e_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para realizar el producto punto llamaremos a la función *numpy.dot*" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " = 0\n" + ] + } + ], + "source": [ + "print(' =',np.dot(a,b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "De igual manera también podemos usar el operador $@$" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " = 0\n" + ] + } + ], + "source": [ + "print(' =',a.T@b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Evaluación de polinomios**. Un polinomio de grado $n-1$ se puede expresar como $p(x) = c_{0} + c_{1}x + c_{2}x^{2} + \\cdots + c_{n-1}x^{n-1}$. Si consideramos los $n$-vectores $\\vec{c},\\vec{x}$ tales que:\n", + "\n", + "$$\n", + "\\vec{c} = \\begin{bmatrix}c_{0}\\\\ c_{1}\\\\ \\vdots \\\\ c_{n-1}\\end{bmatrix},\\qquad \\vec{x}(x) = \\begin{bmatrix}x^{0}\\\\ x^{1}\\\\ \\vdots \\\\ x^{n-1}\\end{bmatrix}\n", + "$$\n", + "\n", + "Así pues, usando estos vectores es posible expresar $p(x) = \\vec{c}^{T}\\vec{x}(x)$. Un ejemplo más concreto sería $p(x)=1+2x$, usando los vectores:\n", + "\n", + "$$\n", + "\\vec{c} = \\begin{bmatrix}1\\\\ 2 \\end{bmatrix}, \\qquad \\vec{x}(x) = \\begin{bmatrix}1\\\\ x \\end{bmatrix}\n", + "$$\n", + "\n", + "Entonces podemos escribir:\n", + "$$\n", + "p(x) = \\vec{c}^{T}\\vec{x}(x) = [1 \\; 2] \\begin{bmatrix}1\\\\ x \\end{bmatrix} = 1\\cdot 1 + 2\\cdot x = 1 + 2x\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Así pues en Python podemos escribir el polinomio como:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def p(x):\n", + " return np.array([1,2])@np.array([1,x])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "p(0) = 1\n", + "p(1) = 3\n", + "p(2) = 5\n" + ] + } + ], + "source": [ + "print('p(0) = ',p(0))\n", + "print('p(1) = ',p(1))\n", + "print('p(2) = ',p(2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.4 Ejercicios." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema 1: Análisis de sentimientos de tweets.** Vamos a crear un máquina que pueda decirnos qué tan positivo, neutral o negativo son una serie de respuestas de twitter. \n", + "Las respuestas son:\n", + "> Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!\n", + "\n", + "> Vaya señora que bueno que se asesora por alguien inteligente no por el ignorante del Gatt.\n", + "\n", + "> Se me ocurre y sin ver todos los videos de Plazti que me informéis por dónde empiezo. Entiendo que os tendría que decir quién soy y que quiero, vamos conocerme para asesorarme bien.\n", + "Un saludo\n", + "\n", + "> Soy docente universitario, estoy intentando preparar mis clases en modo platzi bien didáctico, (le llamo modo noticiero), descargue una plataforma gratuita de grabación y transmisión de vídeo, se llama Obs estudio!bueno la sigo remando con sus funciones pero sé que saldrá algo!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "a = \"Gran mexicano y excelente en su área, su muerte es una enorme perdida y debería ser luto nacional!!!\"\n", + "a = a.replace(\"!\",\"\").replace(\",\",\"\").split(\" \")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Gran',\n", + " 'mexicano',\n", + " 'y',\n", + " 'excelente',\n", + " 'en',\n", + " 'su',\n", + " 'área',\n", + " 'su',\n", + " 'muerte',\n", + " 'es',\n", + " 'una',\n", + " 'enorme',\n", + " 'perdida',\n", + " 'y',\n", + " 'debería',\n", + " 'ser',\n", + " 'luto',\n", + " 'nacional']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sí\n" + ] + } + ], + "source": [ + "if 'muerte' in a:\n", + " print(\"Sí\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora bien, no podemos sacar toda la información de los textos sino vamos a buscar cadenas (strings) específicas. Así pues vamos a construir una función de Python que cuente la cantidad de veces que aparece cierta cadena. Como ejemplo, supongamos que las palabras que vamos a contar son *muerte*, *pérdida*, *luto*, *excelente*,*gran* y *positivo*, y además esto lo queremos expresar como vector en orden respectivo, así pues el primer comentario lo podemos expresar como el siguiente vector:\n", + "$$\n", + "\\vec{w} = \\begin{bmatrix}1\\\\ 1 \\\\ 1\\\\ 1\\\\ 1 \\\\0 \\end{bmatrix}\n", + "$$\n", + "Ahora, vamos a crear otra función en la que tendremos el vector con entradas de cantidad de palabras positivas, negativas y neutras. Siguiendo con el ejemplo vamos a sumar un uno a la primer entrada si aparece alguna de las siguientes palabras *excelente*,*gran* y *positivo*, un uno en la segunda por cada vez que aparezca la palabra *pérdida* y un uno a la última entrada si aparecen las palabras *muerte* y *luto*. Así pues, el primer twett lo podemos representar como:\n", + "\n", + "$$\n", + "\\vec{s} = \\begin{bmatrix} 2 \\\\ 1 \\\\2 \\end{bmatrix}\n", + "$$\n", + "\n", + "Ahora, para ver la *calidad* del resultado que tendremos para un twett conviene calcular el promedio de las entradas de un vector de palabras\n", + "$$avg(\\vec{w}) = (\\mathbf{1}/n)^{T}\\vec{w}$$\n", + "Y después calcularás el promedio del sentimiento de cada tweet $avg(\\vec{s})$ y de igual manera el *score sentimental* que se define como \n", + "$$score(\\vec{s}) = [1\\; 0\\; -1] \\begin{bmatrix} s_{0} \\\\ s_{1} \\\\s_{2} \\end{bmatrix}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Leyendo los tuits decide el conjunto mínimo de palabras que vas a contar en todos los tuits, solamente deberás hacer una función para contar palabras para todos los tuits, no hagas un función por enunciado. Según tu esquema reponde lo siguiente:\n", + "\n", + "* ¿Qué tuit es más positivo?\n", + "\n", + "* ¿Qué tuit es más negativo?\n", + "\n", + "* ¿Cuál es tu calidad promedio?\n", + "\n", + "* ¿Cómo interpretas $avg(\\vec{s})$ y $score(\\vec{s})$?\n", + "\n", + "* ¿Cómo relacionas la calidad con $score(\\vec{s})$ y $avg(\\vec{s})$?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-16-18-am_814169ee-b3bd-4e99-aa84-2fba65f26816.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-16-18-am_814169ee-b3bd-4e99-aa84-2fba65f26816.png" new file mode 100644 index 0000000000000000000000000000000000000000..2463f99bd06e35f91485c3046e1798e94a735bb9 Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-16-18-am_814169ee-b3bd-4e99-aa84-2fba65f26816.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_8975d699-1c37-4b6b-a9f7-f8c2b86e0c8e.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_8975d699-1c37-4b6b-a9f7-f8c2b86e0c8e.png" new file mode 100644 index 0000000000000000000000000000000000000000..8a1e2d6b60bd8cadb08a78d6dbe8a6468610578f Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_8975d699-1c37-4b6b-a9f7-f8c2b86e0c8e.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_af62d54c-3dc7-42ee-b203-dbbc6f8bbdd8.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_af62d54c-3dc7-42ee-b203-dbbc6f8bbdd8.png" new file mode 100644 index 0000000000000000000000000000000000000000..8a1e2d6b60bd8cadb08a78d6dbe8a6468610578f Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_af62d54c-3dc7-42ee-b203-dbbc6f8bbdd8.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_d85e6d28-607e-4064-b558-a9bad63631b8.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_d85e6d28-607e-4064-b558-a9bad63631b8.png" new file mode 100644 index 0000000000000000000000000000000000000000..8a1e2d6b60bd8cadb08a78d6dbe8a6468610578f Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/02-Vectores/10-screen-shot-2021-02-23-at-7-17-04-am_d85e6d28-607e-4064-b558-a9bad63631b8.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Funciones Lineales Transformaci\303\263n de Vectores en Escalares.mp4" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Funciones Lineales Transformaci\303\263n de Vectores en Escalares.mp4" new file mode 100644 index 0000000000000000000000000000000000000000..1c8bd98926fe8720888749a062a3a78d84d33254 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Funciones Lineales Transformaci\303\263n de Vectores en Escalares.mp4" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0275abd0271c690501c5554bd6b3b62d90883593e8869cf504c47bab5c00334a +size 108234493 diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Funciones Lineales Transformaci\303\263n de Vectores en Escalares.vtt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Funciones Lineales Transformaci\303\263n de Vectores en Escalares.vtt" new file mode 100644 index 0000000000000000000000000000000000000000..c1e3ce9c03eb88f11d2d36f7e2b4f18fd6a460b5 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Funciones Lineales Transformaci\303\263n de Vectores en Escalares.vtt" @@ -0,0 +1,607 @@ +WEBVTT + +00:00:03.040 --> 00:00:06.080 +Hola, te doy la bienvenida de nuevo. En + +00:00:06.080 --> 00:00:08.340 +esta clase vamos a hablar de funciones lineales. + +00:00:08.880 --> 00:00:11.780 +En el pasado ya vimos operaciones entre vectores + +00:00:12.080 --> 00:00:15.044 +y operaciones entre vectores y escalares. Operaciones entre + +00:00:15.044 --> 00:00:18.517 +vectores vimos, por ejemplo, el producto punto y + +00:00:18.517 --> 00:00:21.845 +la suma, y operación entre escalar y vector + +00:00:21.845 --> 00:00:25.605 +vimos el producto escalar vector. Ahora, vamos a + +00:00:25.605 --> 00:00:27.845 +introducir las funciones y vamos a ver cómo + +00:00:27.845 --> 00:00:30.930 +las funciones van a tomar vectores y nos + +00:00:30.930 --> 00:00:33.910 +van a ayudar a poder transformarlos en escalares. + +00:00:34.610 --> 00:00:36.530 +Este es un tipo de funciones y más + +00:00:36.530 --> 00:00:39.730 +adelante hablaremos de ellas. Sin más, vamos a + +00:00:39.730 --> 00:00:43.890 +la computadora. Ahora, para denotar una función, digamos + +00:00:43.890 --> 00:00:45.795 +que la función se va a llamar f, + +00:00:45.795 --> 00:00:48.355 +la vamos a denotar como f, una función + +00:00:48.355 --> 00:00:51.414 +que va de RNAR. Esto va a significar + +00:00:51.954 --> 00:00:55.875 +que el dominio de f es RNY la + +00:00:55.875 --> 00:00:58.434 +imagen es r. Lo que esto simplemente nos + +00:00:58.434 --> 00:01:00.034 +quiere decir es que va a tomar un + +00:01:00.034 --> 00:01:01.830 +n vector y este n vector lo va + +00:01:01.830 --> 00:01:04.950 +a convertir en un escalar. Un ejemplo de + +00:01:04.950 --> 00:01:07.910 +función o de operación que hace esto, por + +00:01:07.910 --> 00:01:10.470 +ejemplo, sería el producto interno, el que vimos + +00:01:10.470 --> 00:01:14.470 +en clases anteriores. Ahora, es muy importante que + +00:01:14.470 --> 00:01:17.935 +esta función esté denotada de manera explícita. Si + +00:01:17.935 --> 00:01:20.415 +no la tenemos denotada de manera explícita, no + +00:01:20.415 --> 00:01:22.815 +vamos a poder trabajar con ellas. ¿Cómo se + +00:01:22.815 --> 00:01:27.475 +denotaría de manera explícita? Bueno, tendríamos una notación + +00:01:27.535 --> 00:01:31.020 +como esta, en donde leemos f de X0F + +00:01:31.020 --> 00:01:35.260 +del vector x igual a una expresión. En + +00:01:35.260 --> 00:01:38.140 +este caso, aquí tenemos f evaluado en cada + +00:01:38.140 --> 00:01:41.473 +una de las componentes del vector, en donde + +00:01:41.473 --> 00:01:43.660 +x va a ser un n vector y + +00:01:43.660 --> 00:01:46.534 +x sí serán las entradas de este vector + +00:01:46.534 --> 00:01:50.634 +x. Algo que es necesario enfatizar es que + +00:01:50.775 --> 00:01:53.814 +f es un escalar, entonces le vamos a + +00:01:53.814 --> 00:01:55.814 +dar de comer vectores y nos va a + +00:01:55.814 --> 00:01:58.730 +arrojar escalares. Vamos a ver un ejemplo o + +00:01:58.730 --> 00:02:03.230 +cómo podríamos ejemplificar esto. Este de acá denotará + +00:02:03.290 --> 00:02:06.110 +nuestro conjunto dominio y este de acá denotará + +00:02:06.250 --> 00:02:08.889 +nuestro conjunto imagen de la función. Lo que + +00:02:08.889 --> 00:02:13.465 +hace una función es que agarra los elementos + +00:02:13.465 --> 00:02:17.165 +del dominio y los lleva hacia la imagen + +00:02:17.185 --> 00:02:20.505 +y, además, los lleva uno a uno. Esto + +00:02:20.505 --> 00:02:23.385 +no necesariamente es así, pero vamos a asumir + +00:02:23.385 --> 00:02:25.385 +que estas funciones son uno a uno, se + +00:02:25.385 --> 00:02:29.760 +llaman funciones biyectivas. Ahora, lo que hace la + +00:02:29.760 --> 00:02:32.480 +función es que, en este caso, va a + +00:02:32.480 --> 00:02:35.040 +tomar un círculo y este círculo lo va + +00:02:35.040 --> 00:02:38.320 +a transformar en un triángulo, y hay que + +00:02:38.320 --> 00:02:40.800 +ver que este triángulo no es igual a + +00:02:40.800 --> 00:02:43.895 +este triángulo y este círculo no es igual + +00:02:43.895 --> 00:02:47.895 +a este círculo. Entonces, siempre que llevemos un + +00:02:47.895 --> 00:02:49.915 +elemento, lo va a llevar a un elemento + +00:02:50.615 --> 00:02:52.055 +de un elemento de dominio lo va a + +00:02:52.055 --> 00:02:54.135 +llevar a un elemento de la imagen y, + +00:02:54.135 --> 00:02:57.670 +además, este elemento del dominio va a dar + +00:02:57.670 --> 00:03:00.630 +un elemento de la imagen al cual ningún + +00:03:00.630 --> 00:03:02.630 +otro de los elementos del dominio va a + +00:03:02.630 --> 00:03:05.670 +dar. Esto se llama la correspondencia uno a + +00:03:05.670 --> 00:03:10.665 +uno. Ahora, ¿qué es lo que está pasando + +00:03:10.665 --> 00:03:13.944 +con nosotros? Es exactamente lo mismo, solamente que, + +00:03:13.944 --> 00:03:17.424 +en lugar de tener círculos, tenemos vectores. Entonces, + +00:03:17.424 --> 00:03:21.305 +por ejemplo, nosotros tenemos el vector XYA este + +00:03:21.305 --> 00:03:26.849 +vector x lo lo transformamos en un escalar + +00:03:27.230 --> 00:03:30.750 +x, en un número. ¿Cómo lo hacemos? A + +00:03:30.750 --> 00:03:38.215 +través de la función f. Regresamos al notebook. + +00:03:40.195 --> 00:03:42.675 +Para describir de manera completa una función f + +00:03:42.675 --> 00:03:44.935 +que vaya de r en la r necesitamos + +00:03:45.715 --> 00:03:47.715 +saber o especificar cuál va a ser el + +00:03:47.715 --> 00:03:53.670 +valor para cualquier vector XRNDXDRN. Eso significará dar + +00:03:53.670 --> 00:03:57.930 +una forma explícita de la función. Por ejemplo, + +00:03:58.470 --> 00:04:01.670 +tomemos f de r cuatro ARYF va a + +00:04:01.670 --> 00:04:04.230 +estar dado por esa expresión de aquí, es + +00:04:04.230 --> 00:04:06.545 +decir, va a tomar este vector x, lo + +00:04:06.545 --> 00:04:08.485 +que va a hacer esta función es devolvernos + +00:04:08.785 --> 00:04:11.345 +la suma de sus componentes. Si vemos hasta + +00:04:11.345 --> 00:04:13.905 +x cero, x uno, x dos y x + +00:04:13.905 --> 00:04:16.625 +tres, es un cuatro vector y suma las + +00:04:16.625 --> 00:04:21.719 +cuatro componentes. Por ejemplo, si nos tomamos el + +00:04:21.719 --> 00:04:24.319 +cuatro vector cero, lo que haría es, como + +00:04:24.319 --> 00:04:26.479 +todas sus entradas son cero, es sumar cuatro + +00:04:26.479 --> 00:04:29.520 +veces cero, cero más cero más cero más + +00:04:29.520 --> 00:04:32.505 +cero, y esto nos arroja un cero. Si + +00:04:32.505 --> 00:04:36.025 +tomamos el cuatro vector uno coma cero coma + +00:04:36.025 --> 00:04:38.985 +cero coma cero, lo que haría sería una + +00:04:38.985 --> 00:04:42.185 +contribución de la primera entrada aquí, que es + +00:04:42.185 --> 00:04:45.465 +uno, y después las demás un cero, cero, + +00:04:45.465 --> 00:04:48.160 +cero, cero, y esto nos da un uno. + +00:04:48.780 --> 00:04:51.820 +Ahora, si evaluamos el vector uno coma uno + +00:04:51.820 --> 00:04:53.900 +coma uno coma uno, es decir, el uno + +00:04:53.900 --> 00:04:58.540 +vector, el uno vector de dimensión cuatro, entonces + +00:04:58.540 --> 00:05:01.100 +tenemos que sumaríamos de la primera entrada un + +00:05:01.100 --> 00:05:03.155 +uno, de la segunda entrada un uno, de + +00:05:03.155 --> 00:05:04.754 +la tercera entrada un uno y de la + +00:05:04.754 --> 00:05:07.315 +cuarta entrada un uno. Esto nos da uno + +00:05:07.315 --> 00:05:09.235 +más uno más uno más uno, y esto + +00:05:09.235 --> 00:05:13.735 +es un cuatro. Ahora, esto es la representación + +00:05:13.955 --> 00:05:19.000 +algebraica. ¿Cómo podemos hacer la representación computacional? Vamos + +00:05:19.000 --> 00:05:22.060 +a eso. Para eso primero vamos a llamar + +00:05:22.920 --> 00:05:30.145 +a nuestra biblioteca de siempre, Numpai. Y después + +00:05:30.445 --> 00:05:33.405 +vamos a declarar nuestra función. ¿Cómo vamos a + +00:05:33.405 --> 00:05:37.085 +declarar nuestra función? Bueno, tenemos que escribir esta + +00:05:37.085 --> 00:05:41.965 +expresión, esta expresión algebraica, tenemos que escribirla de + +00:05:41.965 --> 00:05:44.870 +una forma computacional, y la forma de hacerlo + +00:05:44.870 --> 00:05:46.730 +va a ser a través de la palabra + +00:05:47.030 --> 00:05:51.770 +reservada def. Entonces, definimos def, la función f, + +00:05:52.310 --> 00:05:55.430 +que recibe un vector x, ¿y qué nos + +00:05:55.430 --> 00:05:59.735 +va a devolver? ¿Qué nos devolvería? Nos devolvería + +00:05:59.875 --> 00:06:03.315 +la suma de las componentes del vector, y + +00:06:03.315 --> 00:06:06.995 +podemos hacerlo así, de manera explícita, como x + +00:06:06.995 --> 00:06:15.350 +cero más x uno más x dos más + +00:06:15.570 --> 00:06:25.905 +x tres. Eso está perfecto y está totalmente + +00:06:25.965 --> 00:06:29.645 +bien, pero de aquí en adelante podemos empezar + +00:06:29.645 --> 00:06:32.065 +y voy a introducir también funciones de NumPy. + +00:06:32.445 --> 00:06:34.845 +Y, en este caso, hay una función en + +00:06:34.845 --> 00:06:38.390 +NumPy que hace exactamente esto. Lo que hace + +00:06:38.390 --> 00:06:42.310 +es n p zoom, llamamos ANP zoom, DXY + +00:06:42.310 --> 00:06:44.230 +lo que va a hacer es sumar todas + +00:06:44.230 --> 00:06:49.290 +las componentes del vector, exactamente esta función. Ahora, + +00:06:49.430 --> 00:06:53.215 +notemos que esta función no necesariamente tiene que + +00:06:53.215 --> 00:06:55.375 +ir de r cuatro a r, le podemos + +00:06:55.375 --> 00:06:57.695 +dar el vector de cualquier tamaño que sea + +00:06:57.695 --> 00:06:59.695 +y lo va a sumar. En particular, vamos + +00:06:59.695 --> 00:07:05.810 +a utilizarla con cuatro vectores. Ahora vamos a + +00:07:05.810 --> 00:07:09.650 +evaluar esta función en estos puntos de aquí + +00:07:09.650 --> 00:07:11.410 +y vamos a corroborar que nos den los + +00:07:11.410 --> 00:07:15.090 +resultados adecuados. Vamos a, entonces, a hacer un + +00:07:15.090 --> 00:07:22.805 +print de f evaluada en el vector cero. + +00:07:23.305 --> 00:07:28.345 +Eso es igual y aquí evaluamos f y + +00:07:28.345 --> 00:07:34.960 +declaramos adentro el vector cero. Cero coma cero + +00:07:34.960 --> 00:07:38.340 +coma cero coma cero, y nos da exactamente + +00:07:38.639 --> 00:07:45.380 +un cero. Vamos a evaluar entonces el vector + +00:07:46.000 --> 00:07:49.695 +uno coma cero coma cero coma cero. Uno + +00:07:49.695 --> 00:07:53.335 +coma cero coma cero coma cero. Y lo + +00:07:53.335 --> 00:07:57.335 +declaramos acá también. Y tenemos que nos da + +00:07:57.335 --> 00:08:00.155 +uno, como acá arriba también lo habíamos hecho. + +00:08:01.870 --> 00:08:04.350 +Y por último, vamos a evaluar el uno + +00:08:04.350 --> 00:08:18.055 +uno uno. Y esto nos da cuatro. Vamos + +00:08:18.055 --> 00:08:23.095 +a otro ejemplo. Vamos a considerar g una + +00:08:23.095 --> 00:08:25.975 +función que toma tres vectores y los transforma + +00:08:25.975 --> 00:08:29.175 +en escalares, y que está definida por esta + +00:08:29.175 --> 00:08:32.520 +relación de aquí. G toma el vector x + +00:08:32.660 --> 00:08:34.900 +y lo convierte en el escalar x cero, + +00:08:34.900 --> 00:08:37.720 +es decir, nos devuelve únicamente la primera entrada. + +00:08:38.740 --> 00:08:41.620 +De esta manera, si nosotros evaluamos el tres + +00:08:41.620 --> 00:08:44.034 +vector cero, nos daría un cero, ya que + +00:08:44.034 --> 00:08:46.035 +la primera entrada es cero, bueno, en realidad + +00:08:46.035 --> 00:08:47.715 +todas las entradas son cero en el vector + +00:08:47.715 --> 00:08:51.235 +cero. Luego, si tomamos el vector cero coma + +00:08:51.235 --> 00:08:53.475 +cero coma uno, que es el tres, este + +00:08:53.475 --> 00:08:56.320 +es un tres vector, nos regresará la primera + +00:08:56.320 --> 00:08:59.760 +entrada únicamente, que sería cero también. Y si + +00:08:59.760 --> 00:09:04.260 +tomamos el vector uno cero cuatro, nos regresaría + +00:09:04.480 --> 00:09:07.040 +un uno, ya que nos regresa únicamente la + +00:09:07.040 --> 00:09:09.635 +primera entrada. Vamos a ver cómo programar esta + +00:09:09.635 --> 00:09:14.967 +función. Entonces, usamos la palabra reservada dev g + +00:09:15.411 --> 00:09:18.115 +de x, y vamos a decirle que nos + +00:09:18.115 --> 00:09:22.295 +regrese, ahora sí explícitamente, únicamente la componente cero. + +00:09:24.030 --> 00:09:30.030 +Y entonces evaluemos estas funciones. Estos estas función + +00:09:30.030 --> 00:09:35.550 +estas, bueno, esta función en estos vectores. Por + +00:09:35.550 --> 00:09:38.085 +ejemplo, para el vector cero, pues tenemos que + +00:09:38.085 --> 00:09:40.725 +esto es simplemente cero, y esa es la + +00:09:40.725 --> 00:09:43.605 +función g. Aquí también llamamos a la función + +00:09:43.605 --> 00:09:48.165 +g y sabemos que evalúa tres vectores. Uno, + +00:09:48.165 --> 00:09:54.699 +dos, tres. Y nos da exactamente cero. Ahora + +00:09:54.699 --> 00:09:58.300 +evaluemos en cero coma cero coma uno, y + +00:09:58.300 --> 00:10:04.865 +nos debería de dar un cero. Evaluamos de + +00:10:04.865 --> 00:10:07.685 +este lado y nos da también un cero. + +00:10:08.144 --> 00:10:11.685 +Y, por último, evaluemos la función en el + +00:10:12.305 --> 00:10:16.305 +uno coma cero coma cuatro, uno coma cero + +00:10:16.305 --> 00:10:19.769 +coma cuatro. Y eso nos debería de dar + +00:10:19.769 --> 00:10:24.750 +un uno, uno coma cero coma cuatro. Perfecto, + +00:10:24.890 --> 00:10:27.790 +nos da exactamente los resultados que estábamos esperando. + +00:10:29.690 --> 00:10:32.915 +Ahora, esas funciones, las que vimos la función + +00:10:32.915 --> 00:10:35.895 +f y la función g, tienen nombres especiales. + +00:10:36.435 --> 00:10:39.555 +F se llama la función suma y, esencialmente, + +00:10:39.555 --> 00:10:41.465 +lo que hace la función suma es que + +00:10:41.465 --> 00:10:44.220 +toma tu vector y lo convierte en un + +00:10:44.220 --> 00:10:47.680 +escalar por medio de sumar los elementos, las + +00:10:47.740 --> 00:10:51.680 +entradas de ese vector. Si tuviéramos la función + +00:10:51.740 --> 00:10:54.540 +suma para tres vectores, sumaría x cero más + +00:10:54.540 --> 00:10:56.685 +x uno más x dos. Si la tuviéramos + +00:10:56.685 --> 00:10:59.405 +para cinco vectores sumaría x cero más x + +00:10:59.405 --> 00:11:01.405 +uno más x dos más x tres más + +00:11:01.405 --> 00:11:05.245 +x cuatro. Y en el caso de la + +00:11:05.245 --> 00:11:07.805 +función g, la función g se llama la + +00:11:07.805 --> 00:11:11.560 +proyección sobre x cero y básicamente lo que + +00:11:11.560 --> 00:11:14.600 +esto nos da es únicamente la componente x + +00:11:14.600 --> 00:11:19.399 +cero. Como vemos, para R tres, para un + +00:11:19.399 --> 00:11:23.240 +espacio de dimensión tres, tenemos tres funciones de + +00:11:23.240 --> 00:11:26.165 +proyección. Tenemos la proyección sobre el x cero, + +00:11:26.165 --> 00:11:28.245 +tenemos la proyección sobre el x uno y + +00:11:28.245 --> 00:11:31.205 +tenemos la proyección sobre el x dos. Tenemos + +00:11:31.205 --> 00:11:33.625 +el número de proyecciones que sea la dimensión. + +00:11:34.005 --> 00:11:36.745 +En el caso de que tengamos un espacio + +00:11:36.765 --> 00:11:39.765 +de dimensión dos, tendríamos dos funciones de proyección, + +00:11:39.765 --> 00:11:41.340 +la que va sobre x cero y la + +00:11:41.340 --> 00:11:43.740 +que va sobre x uno. Hasta aquí llega + +00:11:43.740 --> 00:11:46.380 +esta clase. Nos vemos en la próxima. Vamos + +00:11:46.380 --> 00:11:50.220 +a seguir con algunas funciones especiales. Nos vemos + +00:11:50.220 --> 00:11:50.720 +allá. diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Lecturas recomendadas.txt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Lecturas recomendadas.txt" new file mode 100644 index 0000000000000000000000000000000000000000..f48d7d0610d5ffb8f175b58b77f6c519d1377b15 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Lecturas recomendadas.txt" @@ -0,0 +1 @@ +https://colab.research.google.com/drive/1uHLHnGyq5fgP917lwwh3JDNhNtr3EZhw?usp=sharing diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Resumen.html" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Resumen.html" new file mode 100644 index 0000000000000000000000000000000000000000..c56625f0f6352d283ee73a64d088a5c77d869823 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-Resumen.html" @@ -0,0 +1,122 @@ + + + + + + + Funciones Lineales: Transformación de Vectores en Escalares + + + +
+
+

Resumen

¿Qué son las funciones lineales y cómo transforman vectores en escalares?

+

Las funciones lineales son una herramienta fundamental en el análisis matemático y el álgebra lineal. Nos permiten transformar vectores en escalares, facilitando la manipulación y análisis de datos en espacios multidimensionales. Al comprender cómo estas funciones operan, podemos aplicar sus principios en diversas áreas como la programación, la estadística, o cualquier campo que implique el uso de vectores y matrices.

+

Una función f, que va de Rⁿ a R, se denota como f: Rⁿ → R. Esto significa que toma un vector de n dimensiones y lo transforma en un escalar. Un buen ejemplo de esto es el producto interno, una operación común que ya hemos visto anteriormente. Para trabajar efectivamente con funciones lineales, es crucial que estas estén explícitamente definidas. Sin una definición clara, las funciones no pueden ser utilizadas adecuadamente en cálculos o programaciones.

+

¿Cómo se representa una función lineal de manera computacional?

+

Para representar las funciones lineales de manera computacional utilizamos bibliotecas como NumPy en Python. Aquí vamos a ver un ejemplo de cómo se puede implementar una función que suma los componentes de un vector.

+
import numpy as np
+
+def f(x):
+    return np.sum(x)
+
+# Evaluamos la función f en diferentes vectores
+print(f(np.array([0, 0, 0, 0])))  # Salida: 0
+print(f(np.array([1, 0, 0, 0])))  # Salida: 1
+print(f(np.array([1, 1, 1, 1])))  # Salida: 4
+
+

En este código, definimos una función f que utiliza np.sum(x) para devolver la suma de las componentes del vector x. Esta implementación no está limitada a vectores de tamaño 4, pero en este ejemplo, estamos trabajando con vectores de cuatro dimensiones para ilustrar el concepto.

+

¿Qué son las funciones de proyección y cómo se implementan?

+

Las funciones de proyección toman un vector y devuelven uno de sus componentes. Veamos cómo se implementa una función de proyección que devuelve solo la primera entrada de un vector.

+
def g(x):
+    return x[0]
+
+# Evaluamos la función g en diferentes vectores
+print(g(np.array([0, 0, 0])))  # Salida: 0
+print(g(np.array([0, 0, 1])))  # Salida: 0
+print(g(np.array([1, 0, 4])))  # Salida: 1
+
+

En esta función g, simplemente se retorna la primera componente del vector x. En un espacio tridimensional, podríamos definir tres funciones de proyección distintas: una sobre la coordenada x₀, otra sobre x₁, y finalmente sobre x₂. La función de proyección que quieras utilizar dependerá del análisis que desees realizar y las características específicas del vector que sean de tu interés.

+

Las funciones lineales, como la suma (función f en el primer ejemplo) o la proyección (función g en el segundo ejemplo), son herramientas poderosas para manipular vectores y comprender los datos en un contexto matemático y computacional. Este conocimiento básico es esencial para trabajar eficazmente en cualquier disciplina que requiera un manejo avanzado de datos y cálculos vectoriales. ¡Sigue explorando y practicando para afinar tus habilidades!

+
+
+ + \ No newline at end of file diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_1_ca9b4768-2259-46e4-8050-1f11fcb161f2.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_1_ca9b4768-2259-46e4-8050-1f11fcb161f2.png" new file mode 100644 index 0000000000000000000000000000000000000000..3170a6b859d3063419f022543cf049e6b531e05c Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_1_ca9b4768-2259-46e4-8050-1f11fcb161f2.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_2_a7a8105b-6058-423e-83cf-1a120fa9dbea.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_2_a7a8105b-6058-423e-83cf-1a120fa9dbea.png" new file mode 100644 index 0000000000000000000000000000000000000000..648cd54cf9d08dbb4ede8ac2f12072c50cf0857d Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_2_a7a8105b-6058-423e-83cf-1a120fa9dbea.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_t1_a1432d51-f125-4847-b35a-aece8c65e623.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_t1_a1432d51-f125-4847-b35a-aece8c65e623.png" new file mode 100644 index 0000000000000000000000000000000000000000..5e9fcfc3dd84b0d1a253d4c61ec432799458012c Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_t1_a1432d51-f125-4847-b35a-aece8c65e623.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_t2_40750924-caa5-49c7-ba5d-2d82e4ed6b3c.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_t2_40750924-caa5-49c7-ba5d-2d82e4ed6b3c.png" new file mode 100644 index 0000000000000000000000000000000000000000..171d935048ecafb519a1879c71d0b45000ac8c01 Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-fl_t2_40750924-caa5-49c7-ba5d-2d82e4ed6b3c.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-funciones_lineales_c6d37f3c-958c-4696-be10-f62382807f2c.ipynb" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-funciones_lineales_c6d37f3c-958c-4696-be10-f62382807f2c.ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..add046e37d000d0da7a02cd1d0a0f05c0d62d420 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/01-funciones_lineales_c6d37f3c-958c-4696-be10-f62382807f2c.ipynb" @@ -0,0 +1,603 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5. Funciones Lineales" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La notación $f: \\mathbb{R}^{n}\\to \\mathbb{R}$ significa que $f$ es una función con **dominio** en $\\mathbb{R}^{n}$ e imagen en $\\mathbb{R}$, es decir, que toma un $n$-vector y lo convierte en un escalar. \n", + "La función puede denotarse como $f\\left(\\mathbf{x}\\right)= f\\left(x_{0},x_{1},\\dots,x_{n-1}\\right)$ donde $\\mathbf{x}\\in \\mathbb{R}^{n}$ y $x_{i}$ son las entradas del vector. \n", + "\n", + "Es necesario enfatizar que $f(\\mathbf{x})$ es un escalar. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para describir una función $f: \\mathbb{R}^{n} \\to \\mathbb{R}$ tenemos que especificar el cual es el valor para cualquier vector $\\mathbf{x}\\in\\mathbb{R}^{n}$. Por ejemplo, sea $f: \\mathbb{R}^{4} \\to \\mathbb{R}$ definida por\n", + "$$\n", + "f(\\mathbf{x}) = x_{0} + x_{1} + x_{2} + x_{3}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Así pues el valor de cualquier $4$-vector queda bien definido, por ejemplo:\n", + "\n", + "* $f(\\mathbf{0}) = 0 + 0+ 0+0 = 0$\n", + "\n", + "* $f([1\\; 0\\; 0\\; 0]) = 1+0+0+0 = 1$\n", + "\n", + "* $f([1\\; 1\\; 1\\; 1]) = 1+1+1+1 = 4$" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " return np.sum(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f(0) = 0\n" + ] + } + ], + "source": [ + "print('f(0) = ',f(np.array([0,0,0,0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f([1,0,0,0]) = 1\n" + ] + } + ], + "source": [ + "print('f([1,0,0,0]) = ',f(np.array([1,0,0,0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f([1,1,1,1]) = 4\n" + ] + } + ], + "source": [ + "print('f([1,1,1,1]) = ',f(np.array([1,1,1,1])))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Como otro ejemplo, sea $g: \\mathbb{R}^{3} \\to \\mathbb{R}$ definida por \n", + "$$\n", + "g(\\mathbf{x}) = x_{0}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tenemos entonces:\n", + "\n", + "* $g(\\mathbf{0}) = 0$ \n", + "\n", + "* $g([0\\; 0\\; 1]) = 0$\n", + "\n", + "* $g([1\\; 0\\; 4]) = 1$" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def g(x):\n", + " return x[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g(0) = 0\n" + ] + } + ], + "source": [ + "print('g(0) = ',g(np.array([0,0,0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g([0,0,1]) = 0\n" + ] + } + ], + "source": [ + "print('g([0,0,1]) = ',g(np.array([0,0,1])))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g([1,0,4]) = 1\n" + ] + } + ], + "source": [ + "print('g([1,0,4]) = ',g(np.array([1,0,4])))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Podemos notar que en este caso $f(\\mathbf{x})$ corresponde a la _función suma_ y $g(\\mathbf{x})$ a proyección sobre $x_{0}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.1 Algunas funciones" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Función producto interno**. Si una función tiene como aurgmentos dos $n$-vectores el dominio de la función se expresará como $\\mathbb{R}^{n}\\times\\mathbb{R}^{n}$. Por ejemplo, sea $f:\\mathbb{R}^{n}\\times\\mathbb{R}^{n} \\to \\mathbb{R}$ definida por:\n", + "\n", + "$$\n", + "f(\\mathbf{a},\\mathbf{b}) = a_{0}b_{0} + a_{1}b_{1} + \\cdots + a_{n-1}b_{n-1}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notemos que podemos expresar lo anterior como\n", + "\n", + "$$\n", + "f(\\mathbf{a},\\mathbf{b}) = \\mathbf{a}^{T}\\mathbf{b}\n", + "$$\n", + "\n", + "Esta función recibe el nombre de función producto interno. Si quisieramos dejar fijo un vector, digamos el vector $\\mathbf{a}$ podemos recurrir a la siguiente notación:\n", + "\n", + "$$\n", + "f_{\\mathbf{a}}(\\mathbf{b}) = \\mathbf{a}^{T}\\mathbf{b}\n", + "$$\n", + "\n", + "Esto significará que $\\mathbf{a}$ estará fijo mientras que $\\mathbf{b}$ será el que variará. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Superposición y linealidad.** La función producto interno satisface la siguiente propiedad:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "f_\\mathbf{x}(\\alpha\\mathbf{a}+\\beta\\mathbf{b}) &=& \\mathbf{x}^{T}(\\alpha\\mathbf{a}+\\beta\\mathbf{b}) \\\\\n", + " &=& \\mathbf{x}^{T}(\\alpha\\mathbf{a})+\\mathbf{x}^{T}(\\beta\\mathbf{b}) \\\\\n", + " &=& \\alpha(\\mathbf{x}^{T}\\mathbf{a}) + \\beta(\\mathbf{x}^{T}\\mathbf{b}) \\\\\n", + " &=& \\alpha f_{\\mathbf{x}}(\\mathbf{a}) + \\beta f_{\\mathbf{x}}(\\mathbf{b})\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "Si la función $g$ cumple que $g(\\alpha\\mathbf{x}+\\beta\\mathbf{y}) = \\alpha g(\\mathbf{x})+\\beta g(\\mathbf{y})$ decimos que la función $g$ es una **función lineal.** " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si $f$ es una función lineal la _linearidad_ se extiende a cualquier combinación lineal y no solamente a una combinación de dos vectores, tenemos \n", + "\n", + "$$\n", + "f(\\alpha_{0}\\mathbf{x_{0}} + \\alpha_{1}\\mathbf{x_{1}} + \\alpha_{2}\\mathbf{x_{2}} + \\cdots \n", + " + \\alpha_{n-1}\\mathbf{x_{n-1}}) = \\alpha_{0}f(\\mathbf{x_{0}}) + \\alpha_{1}f(\\mathbf{x_{1}}) + \\alpha_{2}f(\\mathbf{x_{2}}) + \\cdots + \\alpha_{n-1}f(\\mathbf{x_{n-1}})\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si una función $g:\\mathbf{R}^{n} \\to \\mathbf{R}$ es lineal sabemo que cumple $g(\\alpha\\mathbf{x}+\\beta\\mathbf{y}) = \\alpha g(\\mathbf{x})+\\beta g(\\mathbf{y})$, propiedad que llamaremos _superposición_. Ahora, la superposición puede ser separada en dos propiedades:\n", + "\n", + "* _Homogeneidad_. Para cualquier $n$-vector $\\mathbf{x}$ y cualquier escalar $\\alpha$ tenemos que $g(\\alpha \\mathbf{x}) = \\alpha g(\\mathbf{x})$\n", + "\n", + "* _Aditividad_. Para cualquier $n$-vector $\\mathbf{x}$ y $\\mathbf{y}$ tenemos que $g(\\mathbf{x}+\\mathbf{y}) = g(\\mathbf{x})+g(\\mathbf{y})$\n", + "\n", + "La homogeneidad nos dice que escalar el argumento es igual que escalar el valor de la función; la aditividad nos indica que sumar los argumentos es igual que sumar los valores de la función. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([1,1,1,1])\n", + "b = np.array([1,0,1,0])\n", + "x,y = 1,-2" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f(x*a + y*b) = 0\n" + ] + } + ], + "source": [ + "print('f(x*a + y*b) = ',f(x*a + y*b))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x*f(a) + y*f(b) = 0\n" + ] + } + ], + "source": [ + "print('x*f(a) + y*f(b) =',x*f(a) + y*f(b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Representación producto interno de una función lineal.** En matemáticas las verdades, cuando son verdades, se demuestran usando argumentos principalmente lógicos. Estas verdades vienen empaquetadas en _teoremas_, _corolarios_ y _lemas_. Si no podemos demostrarlo pero creemos que es verdad lo llamamos _conjetura_. Por ejemplo, consideremos el siguiente teorema:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Teorema.** Los ángulos a ambos lados de una recta, que intersecta a otra, siempre suman $180^\\circ$ \n", + "\n", + "![img](fl_1.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Demostración*: Supongamos que $\\alpha + \\beta \\neq 180$ eso quiere decir que $\\alpha + \\beta > 180$ o $\\alpha + \\beta < 180$. Ahora, pensemos en la linea **f** pasa por el diámetro, es decir, corta a la mitad al círculo. \n", + "\n", + "![](fl_t1.png)\n", + "\n", + "Al pasar por el diámetro sabemos que ambos lados tenemos un ángulo de $180^\\circ$. Llamemos a ese ángulo $\\Omega=180^\\circ$. Ahora, llamemos **g** a una línea que pase por otro diámetro. \n", + "\n", + "![](fl_t2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Entonces, al seccionar con **g** tenemos nuevamente los ángulos $\\alpha$ y $\\beta$ entonces tenemos que $\\alpha + \\beta = \\Omega$ pero asumimos que $\\alpha + \\beta \\neq 180^\\circ$ lo cuyal nos lleva a una contradicción $!$ por ello lo anteior debe ser cierto. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Corolario.** Cuando dos líneas se intersectan los ángulos opuestos entre ellos son iguales.\n", + "\n", + "![](fl_2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Demostración:* Sabemos que $\\beta + \\alpha = 180^\\circ$ entonces $\\alpha = 180^\\circ - \\beta$. Por otro lado, sabemos que también $\\gamma + \\beta = 180^\\circ$ así pues $\\gamma = 180^\\circ - \\beta$. Juntando lo anteior tenemos que:\n", + "\n", + "$$\n", + "\\alpha = 180^\\circ - \\beta = \\gamma\n", + "$$\n", + "\n", + "Lo mismo es posible aplicarse para $\\beta$ y $\\delta$. **QED**. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ya explorados los teoremas y los corolarios veamos la siguiente proposición: \n", + "\n", + "**Proposición:** Una función definida como el producto punto de sus argumentos y algún vector fijo es lineal. Lo inverso es también verdadero: si una función es lineal entonces puede ser expresada como el producto interno de sus argumentos y algún vector fijo." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora, sea $f$ una función escalar de $n$-vectores que además es lineal. Entonces decimos que _existe_ un $n$-vector $\\mathbf{a}$ tal que $f(\\mathbf{x}) = \\mathbf{a}^{T}\\mathbf{x}$ para cualquier $\\mathbf{x}$. A la expresión $\\mathbf{a}^{T}\\mathbf{x}$ le llamaremos *representación producto punto* de $f$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Otra propiedad interesante es que la *representación producto punto* de $f$ como $\\mathbf{a}^{T}\\mathbf{x}$ es única. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$ f(\\mathbf{x}) = \\displaystyle\\sum_{i}^{n-1} x_{i}$ si n=4 esto lo podemos expresar como $f(\\mathbf{x}) = \\mathbf{a}^{T}\\mathbf{x}$ donde:\n", + "$$\n", + "a^T = [1,1,1,1]\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Promedio.** El promedio de una $n$-vector es definida como\n", + "\n", + "$$\n", + "f(x) = (x_{0}+x_{1}+\\cdots+x_{n-1})/n\n", + "$$\n", + "\n", + "Y se denota como $\\mathbf{avg}(x)$, notemos que este $\\mathbf{avg}(x) = a^{T}x$ con\n", + "\n", + "$$\n", + "a^T = [1/n\\; 1/n\\; \\cdots \\; 1/n] = \\mathbf{1}/n\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Máximo.** Para $n$-vectores $x$ la función que nos da el máximo coeficiente de un vector es $f(x)=max\\{x_{0},x_{1},\\dots,x_{n-1}\\}$ y no es lineal. Para demostrar esto voy a suponer que es lineal y dar un contraejemplo. Si tomamos $x^T = [1,-1]$ y $y^T=[-1,1]$ con $\\alpha = 1/2$ y $\\beta = 1/2$. Entonces tenemos que:\n", + "\n", + "$$\n", + "f(\\alpha x + \\beta y) = 0 \\neq \\alpha f(x) + \\beta f(y) = 1\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def MAX(x):\n", + " return np.max(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAX([1,0,2]) = 2\n" + ] + } + ], + "source": [ + "print('MAX([1,0,2]) = ', MAX(np.array([1,0,2])))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.array([1,-1])\n", + "y = np.array([-1,1])\n", + "a,b = 1/2, 1/2" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAX(a*x + b*y) = 0.0\n" + ] + } + ], + "source": [ + "print('MAX(a*x + b*y) = ', MAX(a*x + b*y))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a*MAX(x) + b*MAX(y) = 1.0\n" + ] + } + ], + "source": [ + "print('a*MAX(x) + b*MAX(y) = ', a*MAX(x) + b*MAX(y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.2 Algunas consideraciones" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Funciones Afines.** Una función $f:\\mathbb{R}^{n} \\to \\mathbb{R}$ es afín si y solo si puede ser expresada como $f(x) = a^{T}x + b$ para algún $n$-vector $a$ y un escalar $b$, es llamado algunas veces *offset* o *bias*. Por ejemplo si consideramos la siguiente función:\n", + "\n", + "$$\n", + "f(x) = 3 + x_{0}+x_{1}+x_{2}\n", + "$$\n", + "\n", + "La podemos representar como \n", + "\n", + "$$\n", + "f(x) = a^T x + b = [1 \\; 1 \\; 1] x + 3\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Una función afín cumplirá la superposición si y solo si la suma de de los coeficientes de la combinación lineal es uno. Es decir, si $f$ es una función afín entonces $f(\\alpha x + \\beta y) = \\alpha f(x)+ \\beta f(y)$ si y solo si $ \\alpha + \\beta = 1$.\n", + "\n", + "*Demostración.* Como $f$ es afín tenemos que $f(x)=a^T x + b$ entonces, usando que $ \\alpha + \\beta = 1$\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "f(\\alpha x + \\beta y) &=& a^T (\\alpha x + \\beta y) + b \\\\\n", + " &=& a^T \\alpha x + a^T \\beta y + (\\alpha + \\beta) b \\\\\n", + " &=& \\alpha a^T x + \\alpha b + \\beta a^T y + \\beta b \\\\\n", + " &=& \\alpha (a^T x + b) + \\beta (a^T y + b) \\\\\n", + " &=& \\alpha f(x) + \\beta f(y)\n", + "\\end{eqnarray}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Ejercicio.** Determina si las siguientes funciones son lineales o no:\n", + "* $f(\\mathbf{x}) = x_{n-1} - x_{0}$\n", + "\n", + "* Si $\\mathbf{x}\\in\\mathbb{R}^{4}$ y $f:\\mathbb{R}^{4} \\to \\mathbb{R}$ definida como $f(\\mathbf{x})=x_{3}+(x_{3}-x_{2})$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema: Potencia en un clúster de procesadores y temperatura.** La temperatura $T$ de un cluster de tres procesadores es una función afín de la potencia de los procesadores $P^T = [P_{0}\\; P_{1}\\; P_{2}]$. Cuando los tres procesadores están en reposo tenemos que $P^T = [10\\; 10\\; 10]$ lo cual nos da una temperatura de $T=35$. Cuando el primer procesador opera a potencia absoluta tenemos que $P^T = [100\\; 10\\; 10]$ y la temperatura se eleva a $T=60$. Cuando el segundo procesador opera a su máxima capacidad tenemos $P^T = [10\\; 100\\; 10]$ y la temperatura se eleva a $T=75$. Cuando el tercer procesador opera a máxima potencia mientras que los otros dos están en reposo tenemos que $P^T = [10\\; 10\\; 100]$ y la temperatura se elevea a $T=65$. Supongamos que los tres procesadores operan a máxima potencia ¿Qué temperatura se alcanza? La temperatura de fusión de los procesadores (a la que los procesadores se derriten) es cerca de $150$ ¿Cuál es la potencia máxima que pueden alcanzar los procesadores para que $T\\le 150$? \n", + "*Hint:* $T(P) = a^T P + b$" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Funciones Lineales y Propiedades de Superposici\303\263n.mp4" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Funciones Lineales y Propiedades de Superposici\303\263n.mp4" new file mode 100644 index 0000000000000000000000000000000000000000..0023dba98d55f44944a97e97bf6d0343d47bce9e --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Funciones Lineales y Propiedades de Superposici\303\263n.mp4" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ca61ff5682b9d3bc6450546dcfb81d4fdcb8426a6526458ea4a841ee48bc17b +size 139603434 diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Funciones Lineales y Propiedades de Superposici\303\263n.vtt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Funciones Lineales y Propiedades de Superposici\303\263n.vtt" new file mode 100644 index 0000000000000000000000000000000000000000..1d511cd9208824ba611ef32f8561851a30626f18 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Funciones Lineales y Propiedades de Superposici\303\263n.vtt" @@ -0,0 +1,700 @@ +WEBVTT + +00:00:03.040 --> 00:00:05.200 +Hola, te doy la bienvenida de nuevo. La + +00:00:05.200 --> 00:00:08.080 +clase pasada definimos las funciones y vimos cómo + +00:00:08.080 --> 00:00:11.200 +operar con ellas de manera algebraica. También vimos + +00:00:11.200 --> 00:00:13.920 +que necesitábamos tener las funciones definidas de manera + +00:00:13.920 --> 00:00:16.575 +explícita para poder operar con ellas y vimos + +00:00:16.575 --> 00:00:19.975 +cómo implementar algún tipo de ellas en Python. + +00:00:19.975 --> 00:00:22.055 +Lo que vamos a ver ahora son algunas + +00:00:22.055 --> 00:00:25.755 +funciones lineales. Sin más, vamos a la computadora. + +00:00:27.494 --> 00:00:29.654 +Este es el notebook que vimos la clase + +00:00:29.654 --> 00:00:32.479 +pasada. Vamos a ver la parte de algunas + +00:00:32.479 --> 00:00:37.360 +funciones. Ahora bien, vamos a empezar con la + +00:00:37.360 --> 00:00:41.520 +función producto interno. Vamos a decir que Eso + +00:00:41.520 --> 00:00:44.125 +eso es muy importante. Lo que vamos a + +00:00:44.125 --> 00:00:46.365 +mencionar ahora es que si una función tiene + +00:00:46.365 --> 00:00:49.405 +como argumento dos n vectores, vamos a expresar + +00:00:49.405 --> 00:00:52.405 +el función, el dominio de la función como + +00:00:52.405 --> 00:00:54.605 +r n cruz r n, asumiendo que los + +00:00:54.605 --> 00:00:57.690 +vectores viven en r n. Notemos la diferencia + +00:00:57.750 --> 00:01:00.230 +entre esta notación y la notación que habíamos + +00:01:00.230 --> 00:01:02.630 +venido manejando acá, en este caso, un r + +00:01:02.630 --> 00:01:05.750 +tres y, en este caso, una rn. Entonces, + +00:01:05.750 --> 00:01:08.890 +básicamente, lo que nos está denotando rn cruz + +00:01:08.950 --> 00:01:12.515 +rn es que vamos a tomar dos vectores, + +00:01:12.515 --> 00:01:14.674 +la función va a tomar dos n vectores + +00:01:14.674 --> 00:01:17.955 +como argumentos. Si tuviera la función tres n + +00:01:17.955 --> 00:01:21.955 +vectores como argumentos, estaríamos denotando r n cruz + +00:01:21.955 --> 00:01:24.650 +r n cruz r n. Sé que a + +00:01:24.650 --> 00:01:27.370 +este momento la cantidad de notación que empezamos + +00:01:27.370 --> 00:01:30.490 +a utilizar se va aumentando, pero el propósito + +00:01:30.490 --> 00:01:33.130 +de este curso es que, a través de + +00:01:33.130 --> 00:01:36.190 +este curso, puedas estar preparado para el siguiente + +00:01:36.410 --> 00:01:39.885 +curso, en donde es totalmente necesaria. Y para + +00:01:39.885 --> 00:01:42.125 +cursos siguientes también va a ser muy necesario + +00:01:42.125 --> 00:01:43.165 +y va a ser muy útil que ya + +00:01:43.165 --> 00:01:47.245 +puedas dar ese tipo de cosas. Ahora, digamos + +00:01:47.245 --> 00:01:49.645 +entonces que tenemos una función que va de + +00:01:49.645 --> 00:01:53.130 +r n cruz RNAR, es decir, toma dos + +00:01:53.130 --> 00:01:55.690 +vectores y esos dos vectores los convierte en + +00:01:55.690 --> 00:01:58.410 +un escalar. Ya hemos visto una función que + +00:01:58.410 --> 00:02:02.810 +hace esto, un una operación. Las clases pasadas + +00:02:02.810 --> 00:02:05.530 +vimos el producto interno y vimos que era + +00:02:05.530 --> 00:02:10.695 +dos dos vectores, se multiplicaban entre ellos, y + +00:02:10.695 --> 00:02:13.115 +lo que nos daba al final era exactamente + +00:02:13.495 --> 00:02:16.135 +un escalar. Vamos a ver cómo esta función + +00:02:16.135 --> 00:02:19.435 +reproduce eso. Entonces, tenemos a la función a + +00:02:19.815 --> 00:02:22.315 +que consume, o que le damos de comer, + +00:02:23.280 --> 00:02:25.380 +dos vectores, el vector a y el vector + +00:02:25.600 --> 00:02:29.060 +b, y esto se define únicamente como a + +00:02:29.600 --> 00:02:31.680 +cero por b cero, es decir, las componentes, + +00:02:31.680 --> 00:02:34.000 +las primeras componentes multiplicadas de a y de + +00:02:34.000 --> 00:02:36.365 +b, más a uno por b uno, más + +00:02:36.365 --> 00:02:38.365 +a dos por b dos, más a n + +00:02:38.365 --> 00:02:44.445 +por b n menos uno. Entonces, notemos que + +00:02:44.445 --> 00:02:47.085 +esta de aquí realmente lo podemos expresar como + +00:02:47.085 --> 00:02:50.170 +una multiplicación de vectores, y esto lo podemos + +00:02:50.170 --> 00:02:53.130 +expresar como f de a b como a + +00:02:53.130 --> 00:02:56.330 +traspuesta por b, donde a traspuesta es este + +00:02:56.330 --> 00:02:58.489 +vector de aquí y b traspuesta es este + +00:02:58.489 --> 00:03:02.650 +vector de acá. Esta función recibe el nombre + +00:03:02.650 --> 00:03:06.355 +de función producto interno, y esto lo hace + +00:03:06.355 --> 00:03:09.954 +totalmente porque es un símil al producto interno + +00:03:09.954 --> 00:03:14.034 +que habíamos venido viendo. Entonces, vamos a ver + +00:03:14.034 --> 00:03:16.114 +un poco más de esta función. Si nosotros + +00:03:16.114 --> 00:03:19.080 +quisiéramos dejar el vector fijo, digamos, el vector + +00:03:19.080 --> 00:03:21.640 +a solamente por decir un vector, la anotación + +00:03:21.640 --> 00:03:25.659 +que seguiríamos es f subíndice del vector a + +00:03:26.040 --> 00:03:28.940 +evaluada en b, y esto es a traspuesta + +00:03:29.159 --> 00:03:31.799 +por b. Ahora, ¿para qué nos serviría en + +00:03:31.799 --> 00:03:35.004 +esta clase de funciones? Nosotros vimos la clase + +00:03:35.004 --> 00:03:38.765 +pasada, o en clases pasadas, que el producto + +00:03:38.765 --> 00:03:41.484 +punto era un indicador de de ortogonalidad, es + +00:03:41.484 --> 00:03:43.805 +decir, si el producto punto entre dos vectores + +00:03:43.805 --> 00:03:46.385 +es igual a cero, significa que esos vectores + +00:03:46.525 --> 00:03:49.160 +estaban a noventa grados, lo que significa que + +00:03:49.160 --> 00:03:52.200 +los vectores son ortogonales. Será muy útil en + +00:03:52.200 --> 00:03:54.680 +el futuro conocer este tipo de funciones y + +00:03:54.680 --> 00:03:57.640 +saber que podemos comparar un vector contra una + +00:03:57.640 --> 00:04:00.760 +serie de vectores para saber contra cuál es + +00:04:00.760 --> 00:04:05.885 +ese ortogonal. Entonces, empecemos aquí, en donde esta + +00:04:05.885 --> 00:04:08.945 +función va a dejar fijo al vector b, + +00:04:09.005 --> 00:04:10.845 +al vector a, y vamos a empezar a + +00:04:10.845 --> 00:04:14.525 +variar el vector b. Ahora, vamos a ver + +00:04:14.525 --> 00:04:16.910 +una propiedad. Esa propiedad es la propiedad de + +00:04:16.910 --> 00:04:19.310 +la superposición, y vamos a ver cómo la + +00:04:19.310 --> 00:04:22.770 +superposición nos lleva a la linealidad o linealidad. + +00:04:24.510 --> 00:04:28.430 +La función producto interno satisface esta propiedad, y + +00:04:28.430 --> 00:04:31.385 +es que, si la función producto interno dejamos + +00:04:31.445 --> 00:04:34.245 +fijo un vector x y la evaluamos en + +00:04:34.245 --> 00:04:36.725 +la combinación, en esta combinación lineal, en este + +00:04:36.725 --> 00:04:39.685 +vector como combinación lineal, lo que tenemos es + +00:04:39.685 --> 00:04:42.759 +que eso es, partiendo de la definición, x + +00:04:42.759 --> 00:04:47.240 +transpuesta, estamos dejando fijo al vector x, por + +00:04:47.240 --> 00:04:49.159 +el vector en el que está siendo evaluado, + +00:04:49.159 --> 00:04:51.259 +que en este caso es esta combinación lineal, + +00:04:52.120 --> 00:04:57.014 +alfa a más beta b. Ahora, por las + +00:04:57.014 --> 00:05:00.854 +propiedades que vimos, la multiplicación se distribuye sobre + +00:05:00.854 --> 00:05:04.935 +la suma, entonces esta multiplicación de vectores es + +00:05:04.935 --> 00:05:09.220 +exactamente lo mismo que la multiplicación por cada + +00:05:09.220 --> 00:05:12.520 +una de de los elementos de la combinación + +00:05:12.660 --> 00:05:18.340 +lineal. Entonces, tenemos que x transpuesta es, que + +00:05:18.340 --> 00:05:20.660 +x transpuesta por la suma de alfa más + +00:05:20.660 --> 00:05:24.225 +a más beta más b es igual a + +00:05:24.245 --> 00:05:28.805 +x traspuesta por alfa veces a más x + +00:05:28.805 --> 00:05:32.885 +traspuesta por beta veces b. Ahora sabemos que + +00:05:32.885 --> 00:05:37.700 +la multiplicación entre escalares y vectores con muta, + +00:05:38.000 --> 00:05:40.639 +y de igual manera es asociativa, por eso + +00:05:40.639 --> 00:05:46.980 +podemos escribir alfa veces x traspuesta por a, + +00:05:47.815 --> 00:05:51.035 +es decir, este escalar lo pasamos para acá. + +00:05:51.575 --> 00:05:55.175 +Y de igual manera podemos escribir beta veces + +00:05:55.175 --> 00:05:58.775 +x transpuesta por b. Este escalar lo pasamos + +00:05:58.775 --> 00:06:01.710 +para acá y multiplica x transpuesta por b. + +00:06:02.509 --> 00:06:05.410 +Ahora, si nos damos cuenta, esto de aquí + +00:06:05.470 --> 00:06:08.530 +y esto de aquí corresponden con las definiciones + +00:06:08.990 --> 00:06:12.430 +que habíamos dado para la función producto interno + +00:06:12.430 --> 00:06:15.414 +evaluado en algún vector. En este caso, aquí + +00:06:15.414 --> 00:06:17.854 +estamos dejando fijo al vector x y la + +00:06:17.854 --> 00:06:21.615 +estamos evaluando en a. Entonces, esto de aquí + +00:06:21.615 --> 00:06:26.995 +lo podemos escribir como f de X0F subíndice + +00:06:27.215 --> 00:06:29.880 +vector x con con x fijo evaluado en + +00:06:30.420 --> 00:06:36.260 +A0FX de a. Y tenemos un escalar afuera, + +00:06:36.260 --> 00:06:40.420 +pasa normal, pasa multiplicando. Entonces, alfa veces f + +00:06:40.420 --> 00:06:43.225 +de x a es igual a alfa por + +00:06:43.225 --> 00:06:46.025 +x traspuesta de a, y lo mismo hacemos + +00:06:46.025 --> 00:06:49.645 +para beta, en donde podemos expresar a beta + +00:06:49.945 --> 00:06:52.365 +veces f de x en b es exactamente + +00:06:53.545 --> 00:07:00.990 +esta expresión. Ahora bien, notemos que si una + +00:07:00.990 --> 00:07:05.070 +función, llamémosle a esa función g, cumple que + +00:07:05.070 --> 00:07:09.345 +g evaluada en esta combinación lineal es igual + +00:07:09.884 --> 00:07:13.564 +a esta combinación lineal de escalares, notemos que + +00:07:13.564 --> 00:07:16.044 +aquí tenemos una combinación lineal de vectores y + +00:07:16.044 --> 00:07:19.324 +aquí de escalares, ya que g de XYG + +00:07:19.324 --> 00:07:22.365 +de y son escalares, o simplemente a esta + +00:07:22.365 --> 00:07:25.530 +suma, entonces decimos que g es una función + +00:07:25.530 --> 00:07:28.730 +lineal. Si cumplen esta propiedad, decimos que es + +00:07:28.730 --> 00:07:31.930 +lineal. También notemos que si f es una + +00:07:31.930 --> 00:07:34.650 +función lineal, llamemos de f a una función + +00:07:34.650 --> 00:07:39.175 +cualquiera, la linealidad o la linealidad se extiende + +00:07:39.175 --> 00:07:42.135 +a cualquier combinación lineal, no únicamente a una + +00:07:42.135 --> 00:07:44.375 +combinación lineal de dos vectores, sino puede ser + +00:07:44.375 --> 00:07:47.495 +una combinación lineal de n vectores. Por ejemplo, + +00:07:47.495 --> 00:07:51.050 +consideremos esta combinación lineal de aquí. Vamos a + +00:07:51.050 --> 00:07:54.170 +evaluar f en esta combinación lineal, pero como + +00:07:54.170 --> 00:07:57.210 +sabemos que f es lineal, entonces cumple esta + +00:07:57.210 --> 00:08:01.530 +propiedad, y la cumple para cualesquiera vectores y + +00:08:01.530 --> 00:08:05.544 +escalares. Entonces, podemos escribir toda esa expresión de + +00:08:05.544 --> 00:08:10.185 +aquí simplemente como cero por f evaluado en + +00:08:10.185 --> 00:08:13.224 +x cero, más alfa uno por f evaluado + +00:08:13.224 --> 00:08:15.465 +en x uno, más alfa dos por f + +00:08:15.465 --> 00:08:18.840 +evaluado en x dos. Y así hasta alfa + +00:08:18.840 --> 00:08:22.280 +n menos uno evaluada la f en x + +00:08:22.280 --> 00:08:27.660 +n menos uno. Ahora, si una función g + +00:08:28.920 --> 00:08:32.905 +va de RNARY además es lineal y tenemos + +00:08:32.905 --> 00:08:36.225 +que cumple esto, a esta propiedad le vamos + +00:08:36.225 --> 00:08:40.505 +a llamar la superposición. Entonces, decimos que una + +00:08:40.505 --> 00:08:44.580 +función es, si una función cumple el principio + +00:08:44.580 --> 00:08:49.940 +de superposición, es lineal. Ahora, veamos que la + +00:08:49.940 --> 00:08:54.220 +superposición puede ser separada en dos propiedades. Esas + +00:08:54.220 --> 00:08:57.985 +propiedades son la homogeneidad, es decir, si tenemos + +00:08:57.985 --> 00:09:01.791 +cualquier n vector x y cualquier escalar alfa, + +00:09:01.958 --> 00:09:05.125 +y si tenemos que la función que definimos + +00:09:05.345 --> 00:09:09.825 +acá cumple que g evaluado en alfa veces + +00:09:09.825 --> 00:09:13.180 +x es igual que alfa veces g de + +00:09:13.480 --> 00:09:16.760 +x, decimos que la función es homogénea, ¿de + +00:09:16.760 --> 00:09:22.380 +acuerdo? Repito, si la función g cumple que + +00:09:22.440 --> 00:09:25.000 +g alfa veces x es igual que alfa + +00:09:25.000 --> 00:09:27.795 +veces g evaluado en x, decimos que la + +00:09:27.795 --> 00:09:31.395 +función es homogénea. Ahora vamos para la propiedad + +00:09:31.395 --> 00:09:35.015 +de la aditividad. Agarremos cualquiera en el vector + +00:09:35.155 --> 00:09:41.475 +XYY. Entonces, tenemos que g evaluado en x + +00:09:41.475 --> 00:09:46.780 +más y es igual a g de x + +00:09:46.780 --> 00:09:50.780 +más g de y. Si g cumple esto, + +00:09:50.780 --> 00:09:54.380 +si cumple esta propiedad, decimos que g es + +00:09:54.380 --> 00:09:56.460 +cumple la propiedad de la actividad o es + +00:09:56.460 --> 00:10:01.315 +aditiva. Y si la función g cumple estas + +00:10:01.315 --> 00:10:05.655 +dos propiedades, entonces decimos que g es lineal, + +00:10:06.275 --> 00:10:08.755 +es decir, si g cumple la homogeneidad y + +00:10:08.755 --> 00:10:13.309 +la aditividad, cumple la superposición, y si cumple + +00:10:13.309 --> 00:10:16.482 +la superposición es lineal. De igual manera, si + +00:10:16.482 --> 00:10:19.655 +es lineal, si ya sabemos que es lineal, + +00:10:19.655 --> 00:10:22.828 +sabemos que cumple la superposición y sabemos que + +00:10:22.828 --> 00:10:28.665 +es homogénea y además que es aditiva. Vamos + +00:10:29.524 --> 00:10:32.084 +a comprobar si la función suma que habíamos + +00:10:32.084 --> 00:10:36.324 +denotado arriba cumple esta propiedad, es decir, si + +00:10:36.324 --> 00:10:39.470 +cumple la superposición. Lo que vamos a comprobar + +00:10:39.530 --> 00:10:41.930 +es si nuestra función f es o no + +00:10:41.930 --> 00:10:45.370 +es lineal. Entonces, recordemos que f ya está + +00:10:45.370 --> 00:10:47.870 +declarada el de arriba, y vamos a agarrar + +00:10:48.330 --> 00:10:51.935 +dos vectores cuales quiera a, supongamos que a + +00:10:51.935 --> 00:10:55.134 +es igual a Hagamos del vector de los + +00:10:55.134 --> 00:11:00.574 +unos, np array, uno coma uno coma uno + +00:11:00.574 --> 00:11:03.475 +coma uno, coma uno, porque g f recibía + +00:11:03.535 --> 00:11:07.010 +cuatro vectores, y b, vamos a ponerlo como + +00:11:07.010 --> 00:11:11.570 +n p array, vamos a elegir el uno + +00:11:11.570 --> 00:11:16.290 +coma cero coma uno coma cero, y vamos + +00:11:16.290 --> 00:11:20.365 +a elegir dos escalares XYY. Vamos a decir + +00:11:20.365 --> 00:11:23.965 +que x es igual a uno y que + +00:11:23.965 --> 00:11:30.365 +y es igual a menos dos. Ahora, si + +00:11:30.365 --> 00:11:33.750 +la función f es lineal, cumple la superposición, + +00:11:34.209 --> 00:11:37.910 +es decir, si yo evalúo f en x + +00:11:38.769 --> 00:11:41.730 +veces, en este caso, x veces a más + +00:11:41.730 --> 00:11:44.629 +y veces b, debería de ser lo mismo + +00:11:44.850 --> 00:11:48.264 +que si yo multiplico x, en este caso + +00:11:48.264 --> 00:11:52.125 +abajo, por g evaluado en a, más y, + +00:11:54.024 --> 00:11:57.165 +más y por g evaluado en el vector + +00:11:57.225 --> 00:12:05.590 +b. Vamos a comprobarlo. Escribimos un print y + +00:12:05.930 --> 00:12:11.770 +tenemos f evaluado en x, que es nuestro + +00:12:11.770 --> 00:12:23.704 +escalar, por a más y por b. Esto + +00:12:23.704 --> 00:12:26.365 +de aquí es igual a, y lo evaluamos, + +00:12:27.870 --> 00:12:30.030 +y nos da un cero. Vamos a comprobar + +00:12:30.030 --> 00:12:34.610 +que es cero. Recordemos que f suma las + +00:12:34.830 --> 00:12:38.530 +entradas, entonces aquí estamos sumando también componentes, primero + +00:12:38.590 --> 00:12:40.990 +sumamos las componentes y después lo evaluamos en + +00:12:40.990 --> 00:12:44.905 +f. Si sumamos las componentes, es decir, la + +00:12:44.905 --> 00:12:54.105 +combinación lineal, esto nos devuelve este arreglo, menos + +00:12:54.105 --> 00:12:57.510 +uno, uno, menos uno, uno, y si nosotros + +00:12:57.570 --> 00:13:00.610 +sumamos componente a componente, este de aquí se + +00:13:00.610 --> 00:13:03.010 +cancela con este de aquí y este de + +00:13:03.010 --> 00:13:05.350 +aquí se cancela con este de aquí, entonces, + +00:13:05.490 --> 00:13:08.450 +en efecto, nos da un cero. Si esta + +00:13:08.450 --> 00:13:12.505 +función cumple la propiedad de la linealidad y + +00:13:12.505 --> 00:13:16.825 +la superposición, debería de ser lo mismo esto + +00:13:16.825 --> 00:13:20.585 +de aquí que evaluarlo como les voy a + +00:13:20.585 --> 00:13:48.045 +mostrar ahora. Quiero evaluarlo así. Que es justo + +00:13:48.105 --> 00:13:50.444 +como nos aparece la propiedad de la superposición. + +00:13:54.010 --> 00:13:55.690 +Y nos damos cuenta que sí es lo + +00:13:55.690 --> 00:13:59.070 +mismo. Ya con esto comprobamos que nuestra función + +00:13:59.130 --> 00:14:02.190 +f, la función suma, es una función lineal. + +00:14:03.050 --> 00:14:05.645 +Te dejo como ejercicio que compruebes si la + +00:14:05.645 --> 00:14:11.005 +función proyección, la función g que habíamos definido + +00:14:11.005 --> 00:14:13.985 +aquí arriba, es una función lineal o no. + +00:14:15.369 --> 00:14:18.809 +Hasta aquí llega esta clase. Nos vemos en + +00:14:18.809 --> 00:14:21.369 +la siguiente, en donde vamos a ver algunos + +00:14:21.369 --> 00:14:21.869 +teoremas. diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Lecturas recomendadas.txt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Lecturas recomendadas.txt" new file mode 100644 index 0000000000000000000000000000000000000000..f48d7d0610d5ffb8f175b58b77f6c519d1377b15 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Lecturas recomendadas.txt" @@ -0,0 +1 @@ +https://colab.research.google.com/drive/1uHLHnGyq5fgP917lwwh3JDNhNtr3EZhw?usp=sharing diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Resumen.html" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Resumen.html" new file mode 100644 index 0000000000000000000000000000000000000000..34c696ba57610ed609b581e77f54527912540f3f --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-Resumen.html" @@ -0,0 +1,153 @@ + + + + + + + Funciones Lineales y Propiedades de Superposición + + + +
+
+

Resumen

¿Qué es una función producto interno y cómo se define?

+

En nuestra búsqueda por entender funciones lineales, una de las primeras que encontramos es la función producto interno. Esta función crucial toma como argumentos dos n-vectores y los convierte en un escalar. Es crucial para operaciones que implican ortogonalidad, un concepto esencial en muchos campos matemáticos y de la ingeniería.

+
    +
  • Definición y notación: Si tenemos la función que va de ( ℝ^n \times ℝ^n ) a ( ℝ ), estos dos vectores, ( a ) y ( b ), se multiplican y el resultado es un escalar. Esto se expresa como: +[ +f(a, b) = a^T \cdot b = a_0b_0 + a_1b_1 + \ldots + a_{n-1}b_{n-1} +] +Donde ( a^T ) es el vector traspuesto de ( a ) y representa las componentes lineales a multiplicar.
    • +
+

¿Cómo se relaciona la función producto interno con la ortogonalidad?

+

El producto interno es un concepto matemático que juega un papel crucial en determinar la ortogonalidad entre vectores. Cuando el producto interno entre dos vectores es cero, estos son ortogonales, es decir, están a 90 grados uno del otro.

+
    +
  • Relación con la ortogonalidad: La función producto interno es utilizada para evaluar esta relación. Si ( f(a, b) = 0 ), entonces los vectores ( a ) y ( b ) son ortogonales.
    • +
  • Ejemplo práctico: Permite comparar un vector contra un conjunto de otros vectores para determinar con cuál es ortogonal.
    • +
+

¿Cuáles son las propiedades de linealidad en funciones?

+

Las funciones lineales, además de su simplicidad en definición, gozan de propiedades únicas como la superposición, que agrupa dos propiedades clave: homogeneidad y aditividad. Estas propiedades aseguran que las combinaciones lineales de vectores se mantengan bajo la misma función.

+

¿En qué consiste la homogeneidad?

+

La homogeneidad es una propiedad que dice que si un escalar multiplica a un vector, la función aplicada al vector escalado será igual al escalar multiplicando la función del vector original.

+
    +
  • Propiedad de homogeneidad: +[ +g(αx) = αg(x) +] +Esto significa que al multiplicar un vector ( x ) por un escalar ( α ), el resultado funcionará de manera proporcional dentro de la función.
    • +
+

¿Cómo funciona la aditividad?

+

En aditividad, la idea es que si tienes dos vectores sumados y los evalúas en la función, es lo mismo que evaluar los resultados de cada función por separado y luego sumarlos.

+
    +
  • Propiedad de aditividad: +[ +g(x+y) = g(x) + g(y) +] +Esto implica que la función suma por separado los resultados de cada evaluación de ( x ) y ( y ).
    • +
+

¿Cómo se comprueba que una función es lineal?

+

Para determinar la linealidad de una función, es necesario verificar si cumple con la propiedad de superposición, la cual es una combinación de homogeneidad y aditividad.

+

Ejemplo práctico

+
    +
  • Definimos la función en Python: Para verificar la linealidad, utilizamos Python y evaluamos una función con vectores ( a ) y ( b ), y escalares ( x ) y ( y ). +
    import numpy as np
+
+a = np.array([1, 1, 1, 1])
+b = np.array([1, 0, 1, 0])
+x = 1
+y = -2
+
+def f(vector):
+    return sum(vector)
+
+fst_result = f(x * a + y * b)
+snd_result = x * f(a) + y * f(b)
+
+assert fst_result == snd_result
+
    +
    • +
+

Este código muestra cómo usar principios algebraicos para comprobar propiedades de linealidad en funciones de suma.

+

La verificar estas propiedades garantiza que al enfrentarse a futuros problemas algebraicos, se posean las herramientas necesarias para abordarlos de manera eficaz. Además, es esencial para cursos avanzados donde estos principios se tornan fundamentales. Con esta base, estás mejor preparado para continuar explorando las aplicaciones y teoremas que provienen de estas funciones lineales. ¡Sigue aprendiendo y expandiendo tus horizontes!

+
+
+ + \ No newline at end of file diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_1_e9705b8d-df25-4f93-9a4b-0290357a6c0c.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_1_e9705b8d-df25-4f93-9a4b-0290357a6c0c.png" new file mode 100644 index 0000000000000000000000000000000000000000..3170a6b859d3063419f022543cf049e6b531e05c Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_1_e9705b8d-df25-4f93-9a4b-0290357a6c0c.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_2_869e4304-cce7-43be-9ed0-d36af00c8797.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_2_869e4304-cce7-43be-9ed0-d36af00c8797.png" new file mode 100644 index 0000000000000000000000000000000000000000..648cd54cf9d08dbb4ede8ac2f12072c50cf0857d Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_2_869e4304-cce7-43be-9ed0-d36af00c8797.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_t1_9abd2d3c-38bc-4596-9bc7-7cb2b4b0d72e.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_t1_9abd2d3c-38bc-4596-9bc7-7cb2b4b0d72e.png" new file mode 100644 index 0000000000000000000000000000000000000000..5e9fcfc3dd84b0d1a253d4c61ec432799458012c Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_t1_9abd2d3c-38bc-4596-9bc7-7cb2b4b0d72e.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_t2_5f9fbb8a-3b72-4513-b759-b5d63f6b3590.png" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_t2_5f9fbb8a-3b72-4513-b759-b5d63f6b3590.png" new file mode 100644 index 0000000000000000000000000000000000000000..171d935048ecafb519a1879c71d0b45000ac8c01 Binary files /dev/null and "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-fl_t2_5f9fbb8a-3b72-4513-b759-b5d63f6b3590.png" differ diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-funciones_lineales_d6135d0f-fc5c-405c-b74f-b88766a8ce07.ipynb" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-funciones_lineales_d6135d0f-fc5c-405c-b74f-b88766a8ce07.ipynb" new file mode 100644 index 0000000000000000000000000000000000000000..add046e37d000d0da7a02cd1d0a0f05c0d62d420 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/02-funciones_lineales_d6135d0f-fc5c-405c-b74f-b88766a8ce07.ipynb" @@ -0,0 +1,603 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5. Funciones Lineales" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La notación $f: \\mathbb{R}^{n}\\to \\mathbb{R}$ significa que $f$ es una función con **dominio** en $\\mathbb{R}^{n}$ e imagen en $\\mathbb{R}$, es decir, que toma un $n$-vector y lo convierte en un escalar. \n", + "La función puede denotarse como $f\\left(\\mathbf{x}\\right)= f\\left(x_{0},x_{1},\\dots,x_{n-1}\\right)$ donde $\\mathbf{x}\\in \\mathbb{R}^{n}$ y $x_{i}$ son las entradas del vector. \n", + "\n", + "Es necesario enfatizar que $f(\\mathbf{x})$ es un escalar. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Para describir una función $f: \\mathbb{R}^{n} \\to \\mathbb{R}$ tenemos que especificar el cual es el valor para cualquier vector $\\mathbf{x}\\in\\mathbb{R}^{n}$. Por ejemplo, sea $f: \\mathbb{R}^{4} \\to \\mathbb{R}$ definida por\n", + "$$\n", + "f(\\mathbf{x}) = x_{0} + x_{1} + x_{2} + x_{3}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Así pues el valor de cualquier $4$-vector queda bien definido, por ejemplo:\n", + "\n", + "* $f(\\mathbf{0}) = 0 + 0+ 0+0 = 0$\n", + "\n", + "* $f([1\\; 0\\; 0\\; 0]) = 1+0+0+0 = 1$\n", + "\n", + "* $f([1\\; 1\\; 1\\; 1]) = 1+1+1+1 = 4$" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " return np.sum(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f(0) = 0\n" + ] + } + ], + "source": [ + "print('f(0) = ',f(np.array([0,0,0,0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f([1,0,0,0]) = 1\n" + ] + } + ], + "source": [ + "print('f([1,0,0,0]) = ',f(np.array([1,0,0,0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f([1,1,1,1]) = 4\n" + ] + } + ], + "source": [ + "print('f([1,1,1,1]) = ',f(np.array([1,1,1,1])))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Como otro ejemplo, sea $g: \\mathbb{R}^{3} \\to \\mathbb{R}$ definida por \n", + "$$\n", + "g(\\mathbf{x}) = x_{0}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tenemos entonces:\n", + "\n", + "* $g(\\mathbf{0}) = 0$ \n", + "\n", + "* $g([0\\; 0\\; 1]) = 0$\n", + "\n", + "* $g([1\\; 0\\; 4]) = 1$" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def g(x):\n", + " return x[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g(0) = 0\n" + ] + } + ], + "source": [ + "print('g(0) = ',g(np.array([0,0,0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g([0,0,1]) = 0\n" + ] + } + ], + "source": [ + "print('g([0,0,1]) = ',g(np.array([0,0,1])))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g([1,0,4]) = 1\n" + ] + } + ], + "source": [ + "print('g([1,0,4]) = ',g(np.array([1,0,4])))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Podemos notar que en este caso $f(\\mathbf{x})$ corresponde a la _función suma_ y $g(\\mathbf{x})$ a proyección sobre $x_{0}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.1 Algunas funciones" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Función producto interno**. Si una función tiene como aurgmentos dos $n$-vectores el dominio de la función se expresará como $\\mathbb{R}^{n}\\times\\mathbb{R}^{n}$. Por ejemplo, sea $f:\\mathbb{R}^{n}\\times\\mathbb{R}^{n} \\to \\mathbb{R}$ definida por:\n", + "\n", + "$$\n", + "f(\\mathbf{a},\\mathbf{b}) = a_{0}b_{0} + a_{1}b_{1} + \\cdots + a_{n-1}b_{n-1}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notemos que podemos expresar lo anterior como\n", + "\n", + "$$\n", + "f(\\mathbf{a},\\mathbf{b}) = \\mathbf{a}^{T}\\mathbf{b}\n", + "$$\n", + "\n", + "Esta función recibe el nombre de función producto interno. Si quisieramos dejar fijo un vector, digamos el vector $\\mathbf{a}$ podemos recurrir a la siguiente notación:\n", + "\n", + "$$\n", + "f_{\\mathbf{a}}(\\mathbf{b}) = \\mathbf{a}^{T}\\mathbf{b}\n", + "$$\n", + "\n", + "Esto significará que $\\mathbf{a}$ estará fijo mientras que $\\mathbf{b}$ será el que variará. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Superposición y linealidad.** La función producto interno satisface la siguiente propiedad:\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "f_\\mathbf{x}(\\alpha\\mathbf{a}+\\beta\\mathbf{b}) &=& \\mathbf{x}^{T}(\\alpha\\mathbf{a}+\\beta\\mathbf{b}) \\\\\n", + " &=& \\mathbf{x}^{T}(\\alpha\\mathbf{a})+\\mathbf{x}^{T}(\\beta\\mathbf{b}) \\\\\n", + " &=& \\alpha(\\mathbf{x}^{T}\\mathbf{a}) + \\beta(\\mathbf{x}^{T}\\mathbf{b}) \\\\\n", + " &=& \\alpha f_{\\mathbf{x}}(\\mathbf{a}) + \\beta f_{\\mathbf{x}}(\\mathbf{b})\n", + "\\end{eqnarray}\n", + "$$\n", + "\n", + "Si la función $g$ cumple que $g(\\alpha\\mathbf{x}+\\beta\\mathbf{y}) = \\alpha g(\\mathbf{x})+\\beta g(\\mathbf{y})$ decimos que la función $g$ es una **función lineal.** " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si $f$ es una función lineal la _linearidad_ se extiende a cualquier combinación lineal y no solamente a una combinación de dos vectores, tenemos \n", + "\n", + "$$\n", + "f(\\alpha_{0}\\mathbf{x_{0}} + \\alpha_{1}\\mathbf{x_{1}} + \\alpha_{2}\\mathbf{x_{2}} + \\cdots \n", + " + \\alpha_{n-1}\\mathbf{x_{n-1}}) = \\alpha_{0}f(\\mathbf{x_{0}}) + \\alpha_{1}f(\\mathbf{x_{1}}) + \\alpha_{2}f(\\mathbf{x_{2}}) + \\cdots + \\alpha_{n-1}f(\\mathbf{x_{n-1}})\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Si una función $g:\\mathbf{R}^{n} \\to \\mathbf{R}$ es lineal sabemo que cumple $g(\\alpha\\mathbf{x}+\\beta\\mathbf{y}) = \\alpha g(\\mathbf{x})+\\beta g(\\mathbf{y})$, propiedad que llamaremos _superposición_. Ahora, la superposición puede ser separada en dos propiedades:\n", + "\n", + "* _Homogeneidad_. Para cualquier $n$-vector $\\mathbf{x}$ y cualquier escalar $\\alpha$ tenemos que $g(\\alpha \\mathbf{x}) = \\alpha g(\\mathbf{x})$\n", + "\n", + "* _Aditividad_. Para cualquier $n$-vector $\\mathbf{x}$ y $\\mathbf{y}$ tenemos que $g(\\mathbf{x}+\\mathbf{y}) = g(\\mathbf{x})+g(\\mathbf{y})$\n", + "\n", + "La homogeneidad nos dice que escalar el argumento es igual que escalar el valor de la función; la aditividad nos indica que sumar los argumentos es igual que sumar los valores de la función. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([1,1,1,1])\n", + "b = np.array([1,0,1,0])\n", + "x,y = 1,-2" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f(x*a + y*b) = 0\n" + ] + } + ], + "source": [ + "print('f(x*a + y*b) = ',f(x*a + y*b))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x*f(a) + y*f(b) = 0\n" + ] + } + ], + "source": [ + "print('x*f(a) + y*f(b) =',x*f(a) + y*f(b))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Representación producto interno de una función lineal.** En matemáticas las verdades, cuando son verdades, se demuestran usando argumentos principalmente lógicos. Estas verdades vienen empaquetadas en _teoremas_, _corolarios_ y _lemas_. Si no podemos demostrarlo pero creemos que es verdad lo llamamos _conjetura_. Por ejemplo, consideremos el siguiente teorema:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Teorema.** Los ángulos a ambos lados de una recta, que intersecta a otra, siempre suman $180^\\circ$ \n", + "\n", + "![img](fl_1.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Demostración*: Supongamos que $\\alpha + \\beta \\neq 180$ eso quiere decir que $\\alpha + \\beta > 180$ o $\\alpha + \\beta < 180$. Ahora, pensemos en la linea **f** pasa por el diámetro, es decir, corta a la mitad al círculo. \n", + "\n", + "![](fl_t1.png)\n", + "\n", + "Al pasar por el diámetro sabemos que ambos lados tenemos un ángulo de $180^\\circ$. Llamemos a ese ángulo $\\Omega=180^\\circ$. Ahora, llamemos **g** a una línea que pase por otro diámetro. \n", + "\n", + "![](fl_t2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Entonces, al seccionar con **g** tenemos nuevamente los ángulos $\\alpha$ y $\\beta$ entonces tenemos que $\\alpha + \\beta = \\Omega$ pero asumimos que $\\alpha + \\beta \\neq 180^\\circ$ lo cuyal nos lleva a una contradicción $!$ por ello lo anteior debe ser cierto. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Corolario.** Cuando dos líneas se intersectan los ángulos opuestos entre ellos son iguales.\n", + "\n", + "![](fl_2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Demostración:* Sabemos que $\\beta + \\alpha = 180^\\circ$ entonces $\\alpha = 180^\\circ - \\beta$. Por otro lado, sabemos que también $\\gamma + \\beta = 180^\\circ$ así pues $\\gamma = 180^\\circ - \\beta$. Juntando lo anteior tenemos que:\n", + "\n", + "$$\n", + "\\alpha = 180^\\circ - \\beta = \\gamma\n", + "$$\n", + "\n", + "Lo mismo es posible aplicarse para $\\beta$ y $\\delta$. **QED**. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ya explorados los teoremas y los corolarios veamos la siguiente proposición: \n", + "\n", + "**Proposición:** Una función definida como el producto punto de sus argumentos y algún vector fijo es lineal. Lo inverso es también verdadero: si una función es lineal entonces puede ser expresada como el producto interno de sus argumentos y algún vector fijo." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ahora, sea $f$ una función escalar de $n$-vectores que además es lineal. Entonces decimos que _existe_ un $n$-vector $\\mathbf{a}$ tal que $f(\\mathbf{x}) = \\mathbf{a}^{T}\\mathbf{x}$ para cualquier $\\mathbf{x}$. A la expresión $\\mathbf{a}^{T}\\mathbf{x}$ le llamaremos *representación producto punto* de $f$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Otra propiedad interesante es que la *representación producto punto* de $f$ como $\\mathbf{a}^{T}\\mathbf{x}$ es única. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$ f(\\mathbf{x}) = \\displaystyle\\sum_{i}^{n-1} x_{i}$ si n=4 esto lo podemos expresar como $f(\\mathbf{x}) = \\mathbf{a}^{T}\\mathbf{x}$ donde:\n", + "$$\n", + "a^T = [1,1,1,1]\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Promedio.** El promedio de una $n$-vector es definida como\n", + "\n", + "$$\n", + "f(x) = (x_{0}+x_{1}+\\cdots+x_{n-1})/n\n", + "$$\n", + "\n", + "Y se denota como $\\mathbf{avg}(x)$, notemos que este $\\mathbf{avg}(x) = a^{T}x$ con\n", + "\n", + "$$\n", + "a^T = [1/n\\; 1/n\\; \\cdots \\; 1/n] = \\mathbf{1}/n\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Máximo.** Para $n$-vectores $x$ la función que nos da el máximo coeficiente de un vector es $f(x)=max\\{x_{0},x_{1},\\dots,x_{n-1}\\}$ y no es lineal. Para demostrar esto voy a suponer que es lineal y dar un contraejemplo. Si tomamos $x^T = [1,-1]$ y $y^T=[-1,1]$ con $\\alpha = 1/2$ y $\\beta = 1/2$. Entonces tenemos que:\n", + "\n", + "$$\n", + "f(\\alpha x + \\beta y) = 0 \\neq \\alpha f(x) + \\beta f(y) = 1\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def MAX(x):\n", + " return np.max(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAX([1,0,2]) = 2\n" + ] + } + ], + "source": [ + "print('MAX([1,0,2]) = ', MAX(np.array([1,0,2])))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.array([1,-1])\n", + "y = np.array([-1,1])\n", + "a,b = 1/2, 1/2" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAX(a*x + b*y) = 0.0\n" + ] + } + ], + "source": [ + "print('MAX(a*x + b*y) = ', MAX(a*x + b*y))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a*MAX(x) + b*MAX(y) = 1.0\n" + ] + } + ], + "source": [ + "print('a*MAX(x) + b*MAX(y) = ', a*MAX(x) + b*MAX(y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5.2 Algunas consideraciones" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Funciones Afines.** Una función $f:\\mathbb{R}^{n} \\to \\mathbb{R}$ es afín si y solo si puede ser expresada como $f(x) = a^{T}x + b$ para algún $n$-vector $a$ y un escalar $b$, es llamado algunas veces *offset* o *bias*. Por ejemplo si consideramos la siguiente función:\n", + "\n", + "$$\n", + "f(x) = 3 + x_{0}+x_{1}+x_{2}\n", + "$$\n", + "\n", + "La podemos representar como \n", + "\n", + "$$\n", + "f(x) = a^T x + b = [1 \\; 1 \\; 1] x + 3\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Una función afín cumplirá la superposición si y solo si la suma de de los coeficientes de la combinación lineal es uno. Es decir, si $f$ es una función afín entonces $f(\\alpha x + \\beta y) = \\alpha f(x)+ \\beta f(y)$ si y solo si $ \\alpha + \\beta = 1$.\n", + "\n", + "*Demostración.* Como $f$ es afín tenemos que $f(x)=a^T x + b$ entonces, usando que $ \\alpha + \\beta = 1$\n", + "\n", + "$$\n", + "\\begin{eqnarray}\n", + "f(\\alpha x + \\beta y) &=& a^T (\\alpha x + \\beta y) + b \\\\\n", + " &=& a^T \\alpha x + a^T \\beta y + (\\alpha + \\beta) b \\\\\n", + " &=& \\alpha a^T x + \\alpha b + \\beta a^T y + \\beta b \\\\\n", + " &=& \\alpha (a^T x + b) + \\beta (a^T y + b) \\\\\n", + " &=& \\alpha f(x) + \\beta f(y)\n", + "\\end{eqnarray}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Ejercicio.** Determina si las siguientes funciones son lineales o no:\n", + "* $f(\\mathbf{x}) = x_{n-1} - x_{0}$\n", + "\n", + "* Si $\\mathbf{x}\\in\\mathbb{R}^{4}$ y $f:\\mathbb{R}^{4} \\to \\mathbb{R}$ definida como $f(\\mathbf{x})=x_{3}+(x_{3}-x_{2})$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Problema: Potencia en un clúster de procesadores y temperatura.** La temperatura $T$ de un cluster de tres procesadores es una función afín de la potencia de los procesadores $P^T = [P_{0}\\; P_{1}\\; P_{2}]$. Cuando los tres procesadores están en reposo tenemos que $P^T = [10\\; 10\\; 10]$ lo cual nos da una temperatura de $T=35$. Cuando el primer procesador opera a potencia absoluta tenemos que $P^T = [100\\; 10\\; 10]$ y la temperatura se eleva a $T=60$. Cuando el segundo procesador opera a su máxima capacidad tenemos $P^T = [10\\; 100\\; 10]$ y la temperatura se eleva a $T=75$. Cuando el tercer procesador opera a máxima potencia mientras que los otros dos están en reposo tenemos que $P^T = [10\\; 10\\; 100]$ y la temperatura se elevea a $T=65$. Supongamos que los tres procesadores operan a máxima potencia ¿Qué temperatura se alcanza? La temperatura de fusión de los procesadores (a la que los procesadores se derriten) es cerca de $150$ ¿Cuál es la potencia máxima que pueden alcanzar los procesadores para que $T\\le 150$? \n", + "*Hint:* $T(P) = a^T P + b$" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/03-Teoremas y Corolarios en Funciones Lineales.mp4" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/03-Teoremas y Corolarios en Funciones Lineales.mp4" new file mode 100644 index 0000000000000000000000000000000000000000..19d25bf96161afaf3a0b749629b682d7640cc105 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/03-Teoremas y Corolarios en Funciones Lineales.mp4" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e12f85b2bc7ed902e1af09bc970fd14e6ea903a1e1c45bcfd396d87f349ac65 +size 173990656 diff --git "a/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/03-Teoremas y Corolarios en Funciones Lineales.vtt" "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/03-Teoremas y Corolarios en Funciones Lineales.vtt" new file mode 100644 index 0000000000000000000000000000000000000000..20985854f352ffd5f29b15d424897245dde95805 --- /dev/null +++ "b/a/Curso de Introducci\303\263n al \303\201lgebra Lineal Vectores/03-Funciones lineales/03-Teoremas y Corolarios en Funciones Lineales.vtt" @@ -0,0 +1,817 @@ +WEBVTT + +00:00:03.040 --> 00:00:07.120 +Te doy la bienvenida de nuevo. Las clases + +00:00:07.120 --> 00:00:09.519 +pasadas lo que hicimos fue introducir el concepto + +00:00:09.519 --> 00:00:12.240 +de función, al igual que introducimos el concepto + +00:00:12.240 --> 00:00:14.625 +de una función lineal, y vimos, de igual + +00:00:14.625 --> 00:00:17.525 +manera, cómo construir funciones en Python y comprobar + +00:00:17.985 --> 00:00:20.865 +si eran funciones lineales o no. Lo que + +00:00:20.865 --> 00:00:23.125 +vamos a hacer ahora es introducir un teorema + +00:00:23.585 --> 00:00:26.064 +matemático en relación a las funciones lineales, que + +00:00:26.064 --> 00:00:29.369 +nos será muy útil hacia el futuro. Sin + +00:00:29.369 --> 00:00:33.210 +más, vamos a la computadora. En matemáticas, las + +00:00:33.210 --> 00:00:36.410 +verdades, cuando son verdades, son verdad, verdad, verdad + +00:00:36.410 --> 00:00:39.290 +para siempre, y eso pasa porque nosotros demostramos + +00:00:39.290 --> 00:00:42.665 +esas verdades a partir de argumentos lógicos, Y + +00:00:43.045 --> 00:00:45.765 +entonces, esas verdades van a venir empaquetadas en + +00:00:45.765 --> 00:00:48.745 +tres en tres paquetes. La primera son teoremas, + +00:00:48.805 --> 00:00:51.605 +después vienen los corolarios y al final los + +00:00:51.605 --> 00:00:54.485 +demás. Y si algo nosotros creemos en el + +00:00:54.485 --> 00:00:56.520 +corazón que es verdad, pero no podemos demostrarlo, + +00:00:57.620 --> 00:01:00.820 +no podemos argumentar, no podemos dar estos argumentos + +00:01:00.820 --> 00:01:04.019 +lógicos para demostrar que es verdad, lo vamos + +00:01:04.019 --> 00:01:07.380 +a llamar una conjetura. Ahora, para ilustrar el + +00:01:07.380 --> 00:01:11.085 +concepto de un teorema y un corolario, vamos + +00:01:11.085 --> 00:01:13.965 +a ilustrarlo con el siguiente teorema, el cual + +00:01:13.965 --> 00:01:17.485 +vamos a demostrar. Nuestro teorema va a ser + +00:01:17.485 --> 00:01:23.299 +este. El teorema nos dice, los ángulos a + +00:01:23.299 --> 00:01:25.940 +ambos lados de una recta que intersecta a + +00:01:25.940 --> 00:01:30.840 +otra siempre suman ciento ochenta grados. Es decir, + +00:01:31.140 --> 00:01:34.100 +si tenemos una recta y a esa recta + +00:01:34.100 --> 00:01:37.414 +la intersectamos con otra, no importa cómo la + +00:01:39.234 --> 00:01:41.395 +intersectemos, esto a este ángulo alfa que se + +00:01:41.395 --> 00:01:43.234 +forma de este lado y este ángulo beta + +00:01:43.234 --> 00:01:45.715 +que se forma de este lado siempre nos + +00:01:45.715 --> 00:01:49.810 +van a sumar ciento ochenta grados. ¿Cómo demostramos + +00:01:49.810 --> 00:01:52.290 +esto? Esto suena a una tontería, pero no + +00:01:52.290 --> 00:01:54.870 +lo es, esto lo podemos demostrar de verdad, + +00:01:55.010 --> 00:01:58.290 +y entonces vamos a hacerlo. Primero, vamos a + +00:01:58.290 --> 00:02:01.835 +hacer una demostración por contradicción, es decir, vamos + +00:02:01.895 --> 00:02:03.735 +a asumir que esto no es cierto, que + +00:02:03.735 --> 00:02:07.315 +no siempre suman ciento ochenta, que existen casos + +00:02:07.495 --> 00:02:09.335 +para los cuales no van a sumar ciento + +00:02:09.335 --> 00:02:13.015 +ochenta. Entonces, suponemos que la suma de alfa + +00:02:13.015 --> 00:02:15.435 +y beta es distinto de ciento ochenta grados. + +00:02:15.879 --> 00:02:19.099 +Esto quiere decir que, como es distinto, la + +00:02:19.159 --> 00:02:21.319 +suma, o bien es mayor a ciento ochenta, + +00:02:21.319 --> 00:02:23.659 +o bien es menor a ciento ochenta grados. + +00:02:25.720 --> 00:02:31.925 +Ahora, pensemos en una línea f, le vamos + +00:02:31.925 --> 00:02:33.685 +a llamar a la línea f, que pasa + +00:02:33.685 --> 00:02:36.005 +por el diámetro de un círculo, es decir, + +00:02:36.005 --> 00:02:38.085 +corta la mitad a un círculo. Miren, aquí + +00:02:38.085 --> 00:02:41.340 +está el círculo y esta línea f pasa + +00:02:41.340 --> 00:02:44.220 +por un diámetro, y aquí está el centro + +00:02:44.220 --> 00:02:48.460 +del círculo, por aquí, ¿vale? Entonces, al pasar + +00:02:48.460 --> 00:02:53.520 +por el diámetro del círculo, sabemos que esta + +00:02:53.740 --> 00:02:58.395 +circunferencia tiene trescientos sesenta grados. Al pasar por + +00:02:59.895 --> 00:03:02.535 +exactamente el centro y por un diámetro, sabemos + +00:03:02.535 --> 00:03:04.775 +que de este lado hay ciento ochenta grados + +00:03:04.775 --> 00:03:06.775 +y que de este lado hay ciento ochenta + +00:03:06.775 --> 00:03:11.400 +grados. Entonces, vamos a llamarle a este ángulo, + +00:03:11.400 --> 00:03:12.680 +sea el de arriba o sea el de + +00:03:12.680 --> 00:03:18.220 +abajo, omega. Omega es igual a ciento ochenta. + +00:03:20.120 --> 00:03:24.114 +Ahora bien, vamos a llamar AGA una línea + +00:03:24.174 --> 00:03:26.575 +que pase por otro de los diámetros del + +00:03:26.575 --> 00:03:29.375 +mismo círculo. Por ejemplo, esta línea g de + +00:03:29.375 --> 00:03:32.575 +aquí. Aquí está el centro del círculo, este + +00:03:32.575 --> 00:03:34.334 +de aquí es un diámetro y este de + +00:03:34.334 --> 00:03:38.110 +aquí es otro diámetro. Entonces, si nos damos + +00:03:38.110 --> 00:03:41.390 +cuenta, g intersecta a la línea f justo + +00:03:41.390 --> 00:03:46.769 +en el centro del círculo. Ahora, con lo + +00:03:48.189 --> 00:03:53.065 +anterior, tenemos que, al seleccionar g, tenemos que + +00:03:53.065 --> 00:03:55.145 +se forma de este lado un ángulo alfa + +00:03:55.145 --> 00:03:56.985 +y de este lado se forma un ángulo + +00:03:56.985 --> 00:04:02.345 +beta, y sabemos que este lado tiene que + +00:04:02.345 --> 00:04:06.350 +sumar ciento ochenta sí o sí. Entonces, el + +00:04:06.350 --> 00:04:09.630 +ángulo formado entre la recta, los ángulos formados + +00:04:09.630 --> 00:04:12.290 +entre la recta f y la recta g + +00:04:12.830 --> 00:04:15.730 +tienen que sumar ciento ochenta sí o sí, + +00:04:16.430 --> 00:04:18.750 +porque la suma de esos ángulos va a + +00:04:18.750 --> 00:04:23.295 +ser exactamente omega. Y si nosotros asumimos que + +00:04:23.295 --> 00:04:26.595 +eso no era cierto, nosotros nos estamos contradiciendo + +00:04:26.815 --> 00:04:30.035 +a nosotros mismos, entonces llegamos a una contradicción, + +00:04:30.895 --> 00:04:34.949 +por lo cual, sí o sí, alfa más + +00:04:34.949 --> 00:04:38.710 +beta tiene que sumar ciento ochenta cuando una + +00:04:38.710 --> 00:04:44.569 +recta intersecta a otra recta. Así nosotros demostramos + +00:04:45.349 --> 00:04:47.750 +que este teorema es verdad y va a + +00:04:47.750 --> 00:04:54.565 +ser una verdad para siempre. Ahora, un corolario + +00:04:54.785 --> 00:04:56.805 +es algo que se deriva de un teorema + +00:04:56.945 --> 00:04:59.425 +o que puede salir de un teorema. Por + +00:04:59.425 --> 00:05:02.165 +ejemplo, vamos a tomar este corolario de acá. + +00:05:04.190 --> 00:05:07.630 +Cuando dos líneas se intersectan, los ángulos opuestos + +00:05:07.630 --> 00:05:11.410 +entre ellos son iguales. Lo que hicimos la + +00:05:11.550 --> 00:05:14.030 +en el teorema anterior fue demostrar que beta + +00:05:14.030 --> 00:05:17.245 +más alfa es igual a ciento ochenta, y + +00:05:17.245 --> 00:05:20.365 +ya sabemos que gamma más delta tiene que + +00:05:20.365 --> 00:05:22.845 +sumar ciento ochenta también sí o sí, no + +00:05:22.845 --> 00:05:25.805 +importa lo que hagamos. De igual manera, gamma + +00:05:25.805 --> 00:05:28.355 +más beta tienen que sumar ciento ochenta y + +00:05:28.355 --> 00:05:33.980 +delta más alfa tienen que sumar ciento ochenta. + +00:05:33.980 --> 00:05:37.740 +Ahora bien, vamos a demostrar este corolario. El + +00:05:37.740 --> 00:05:41.260 +corolario nos dice que este ángulo gamma es + +00:05:41.260 --> 00:05:43.979 +igual a este ángulo alfa, a eso se + +00:05:43.979 --> 00:05:47.015 +le llaman ángulos opuestos, y este ángulo beta + +00:05:47.155 --> 00:05:49.635 +es igual a este ángulo delta, esos también + +00:05:49.635 --> 00:05:54.355 +son ángulos opuestos. Vamos a demostrarlo. Sabemos que + +00:05:54.355 --> 00:05:56.595 +beta más alfa tiene que sumar ciento ochenta + +00:05:56.595 --> 00:05:58.595 +por el teorema anterior, y sabemos que eso + +00:05:58.595 --> 00:06:03.720 +es verdad siempre, siempre. Entonces, despejando alfa, tenemos + +00:06:03.720 --> 00:06:07.160 +que alfa es igual a ciento ochenta menos + +00:06:07.160 --> 00:06:11.960 +beta. Por otro lado, sabemos que también gamma + +00:06:11.960 --> 00:06:14.440 +más beta tienen que sumar ciento ochenta por + +00:06:14.440 --> 00:06:19.235 +el teorema anterior. Entonces, sabemos que gamma, despejando + +00:06:19.295 --> 00:06:22.675 +gamma, es igual a ciento ochenta menos beta. + +00:06:23.935 --> 00:06:26.415 +Ahora, notemos que, en este caso, ciento ochenta + +00:06:26.415 --> 00:06:28.895 +menos beta y ciento ochenta menos beta es + +00:06:28.895 --> 00:06:32.020 +igual, por lo cual tenemos que alfa, que + +00:06:32.020 --> 00:06:34.900 +es igual a ciento ochenta menos beta, es + +00:06:34.900 --> 00:06:37.380 +igual a gamma, porque gamma es igual también + +00:06:37.380 --> 00:06:39.780 +a ciento ochenta menos beta, con lo que + +00:06:39.780 --> 00:06:45.035 +concluimos que alfa es igual a gamma, es + +00:06:45.035 --> 00:06:47.775 +decir, este ángulo es igual a este ángulo. + +00:06:48.475 --> 00:06:51.854 +Lo mismo podemos aplicar para beta y gamma, + +00:06:54.315 --> 00:06:58.820 +para beta y delta. Ahora bien, solamente como + +00:06:58.820 --> 00:07:01.700 +comentario, algunas veces después de una demostración o + +00:07:01.700 --> 00:07:05.460 +terminando la demostración se pone qd. Qd lo + +00:07:05.460 --> 00:07:10.695 +podríamos decir como queda entonces demostrado, sabiendo que + +00:07:10.695 --> 00:07:14.135 +este argumento final fue tan suficiente, o bueno, + +00:07:14.135 --> 00:07:16.455 +la serie de argumentos que vimos lógicos fue + +00:07:16.455 --> 00:07:19.895 +tan suficiente o fue tal la suficiencia que + +00:07:19.895 --> 00:07:22.535 +ya demostraron lo que queríamos demostrar, que en + +00:07:22.535 --> 00:07:24.750 +este caso fue este corolario. Aquí, por ejemplo, + +00:07:24.750 --> 00:07:27.710 +no puse un qede, no es necesario siempre + +00:07:27.710 --> 00:07:30.030 +y cuando se vea que la demostración tiene + +00:07:30.030 --> 00:07:34.510 +un final. Ahora bien, ya explorados lo que + +00:07:34.510 --> 00:07:37.090 +son los teoremas y lo que son las + +00:07:37.310 --> 00:07:41.074 +proposiciones, los los corolarios, vamos a plantear la + +00:07:41.074 --> 00:07:46.595 +siguiente proposición. Cuando queremos plantear un teorema pero + +00:07:46.595 --> 00:07:49.495 +todavía no lo hemos demostrado, le llamamos proposición. + +00:07:51.300 --> 00:07:54.520 +Sí, no podemos demostrarlo, pero tenemos la suficiente + +00:07:55.139 --> 00:07:57.380 +evidencia para creer que es real, le llamamos + +00:07:57.380 --> 00:08:01.960 +conjetura. En este caso, nuestra proposición es esta. + +00:08:02.100 --> 00:08:04.500 +Una función definida como el producto punto de + +00:08:04.500 --> 00:08:04.606 +sus argumentos y algún vector fijo es lineal. + +00:08:04.606 --> 00:08:07.405 +Entonces, si tenemos una función que fijo es + +00:08:07.405 --> 00:08:10.285 +lineal, entonces, si tenemos una función que se + +00:08:10.285 --> 00:08:12.705 +define como el producto punto de sus argumentos + +00:08:12.845 --> 00:08:16.765 +y algún vector, entonces esa función ya sabemos + +00:08:16.765 --> 00:08:21.180 +que es lineal. Y lo inverso también es + +00:08:21.400 --> 00:08:24.360 +verdadero. Si una función es lineal, entonces eso + +00:08:24.360 --> 00:08:27.800 +significa que podemos expresarla como el producto interno + +00:08:27.800 --> 00:08:31.534 +de sus argumentos y algún vector fijo. Vamos + +00:08:31.534 --> 00:08:34.115 +a ver cómo se aplica esto. Para eso + +00:08:34.255 --> 00:08:41.214 +necesitamos conocer la representación de producto punto. Vamos + +00:08:41.214 --> 00:08:44.620 +a a definirla aquí abajo. Cdf es una + +00:08:44.620 --> 00:08:48.060 +función escalar de n vectores que además es + +00:08:48.060 --> 00:08:51.500 +lineal. F sabemos que es una función que + +00:08:51.500 --> 00:08:54.060 +toma n vectores, los convierte en escalares y + +00:08:54.060 --> 00:08:57.155 +que además cumple la propiedad de linealidad. Entonces, + +00:08:57.775 --> 00:09:00.755 +decimos que existe un n vector a tal + +00:09:00.815 --> 00:09:04.975 +que f de x es igual a ese + +00:09:04.975 --> 00:09:08.335 +vector a transpuesto por nuestro vector x para + +00:09:08.335 --> 00:09:13.090 +cualquier x. A la expresión a traspuesta por + +00:09:13.090 --> 00:09:17.250 +x le llamamos la representación producto punto d + +00:09:17.250 --> 00:09:20.930 +f. Otra propiedad muy interesante es que la + +00:09:20.930 --> 00:09:25.045 +representación producto punto d f es única. Vamos + +00:09:25.045 --> 00:09:26.805 +a ver un ejemplo con las funciones que + +00:09:26.805 --> 00:09:33.045 +hemos venido trabajando hasta ahora. Nosotros teníamos que + +00:09:33.045 --> 00:09:36.985 +la función f, la función f, si se + +00:09:37.125 --> 00:09:40.960 +si recordamos un poco, la habíamos definido como + +00:09:40.960 --> 00:09:44.160 +f de x, vamos a definir esto como + +00:09:44.160 --> 00:10:10.029 +un vector, era igual AXA la suma de + +00:10:10.029 --> 00:10:21.165 +los XEYA la suma de sus componentes. Esto + +00:10:21.165 --> 00:10:23.404 +es lo que teníamos que definir la función + +00:10:23.404 --> 00:10:27.165 +f, pero notemos que, en el caso de + +00:10:27.165 --> 00:10:31.840 +que sea un cuatro vector, es decir, si + +00:10:32.140 --> 00:10:34.240 +n es igual a cuatro o hay dimensión + +00:10:34.780 --> 00:10:45.415 +f, esto lo podemos expresar como f, vamos + +00:10:45.415 --> 00:10:57.695 +a agarrar esa expresión de acá también como + +00:10:57.695 --> 00:11:03.300 +f de a traspuesta por x, donde nuestro + +00:11:03.300 --> 00:11:11.300 +vector a va a ser simplemente el vector + +00:11:11.300 --> 00:11:14.525 +uno coma uno coma uno coma uno, y + +00:11:14.525 --> 00:11:17.005 +entonces, cuando eso lo multipliquemos por el vector + +00:11:17.005 --> 00:11:18.125 +x, lo que va a hacer va a + +00:11:18.125 --> 00:11:25.425 +ser sumar las componentes de x. Ahora bien, + +00:11:25.645 --> 00:11:28.940 +veamos otros dos ejemplos. Vamos a partir de + +00:11:28.940 --> 00:11:32.320 +la función promedio. El promedio de un nvector + +00:11:32.459 --> 00:11:34.860 +lo vamos a definir como la función toma + +00:11:34.860 --> 00:11:39.339 +el vector x y suma sus componentes hasta + +00:11:39.339 --> 00:11:47.415 +n menos uno, y lo divide entre su + +00:11:47.415 --> 00:11:51.834 +dimensión. A esta función la podemos denotar como + +00:11:52.455 --> 00:11:57.700 +AVG, por inglés, average, y el average evaluado + +00:11:57.760 --> 00:12:01.300 +en x. Notemos que esta función la podemos + +00:12:01.360 --> 00:12:07.040 +expresar también como a traspuesta por x, donde + +00:12:07.040 --> 00:12:10.080 +a traspuesta es el vector uno entre n, + +00:12:10.080 --> 00:12:13.345 +uno entre n, uno entre n, n veces, + +00:12:14.125 --> 00:12:17.885 +y eso es simplemente el vector uno de + +00:12:17.885 --> 00:12:21.485 +dimensión n por uno entre n, por el + +00:12:21.485 --> 00:12:27.070 +escalar uno entre n. Ahora, vamos a ver + +00:12:27.070 --> 00:12:30.450 +el caso de la función máximo. Si consideramos + +00:12:31.150 --> 00:12:35.710 +nvectores, o un nvector x, la función que + +00:12:35.710 --> 00:12:38.530 +nos da el máximo coeficiente o el máximo + +00:12:39.150 --> 00:12:42.985 +elemento de un vector se denota así, f + +00:12:43.084 --> 00:12:46.645 +de x igual al máximo de x cero, + +00:12:46.645 --> 00:12:49.765 +x uno, hasta x n menos uno, y + +00:12:49.765 --> 00:12:53.570 +esta función no es lineal. Para demostrar que + +00:12:53.570 --> 00:12:55.890 +algo no es verdad, lo que hacemos es + +00:12:55.890 --> 00:13:00.290 +dar un contraejemplo, ¿vale? Entonces, por ejemplo, si + +00:13:00.290 --> 00:13:04.745 +tomamos la función, si tomamos los vectores x + +00:13:04.745 --> 00:13:08.065 +t igual a uno menos XYY de t + +00:13:08.065 --> 00:13:11.585 +igual a uno menos a menos uno coma + +00:13:11.585 --> 00:13:14.385 +uno, con alfa igual a un medio y + +00:13:14.385 --> 00:13:17.265 +beta igual a un medio, tenemos que si + +00:13:17.265 --> 00:13:21.399 +hacemos esta combinación lineal, el máximo nos da + +00:13:21.399 --> 00:13:26.279 +un cero, y esto es totalmente distinto a + +00:13:26.279 --> 00:13:29.480 +que si lo hacemos de manera individual, si + +00:13:29.480 --> 00:13:33.320 +evaluamos los vectores y después les multiplicamos el + +00:13:33.320 --> 00:13:35.855 +escalar. En este caso nos da un uno. + +00:13:36.315 --> 00:13:41.295 +Vamos a comprobarlo. En el caso de NumPy, + +00:13:41.595 --> 00:13:44.074 +NumPy también nos ayuda a poder calcular la + +00:13:44.074 --> 00:13:47.355 +función máximo. Entonces, a esta función máximo lo + +00:13:47.355 --> 00:13:50.779 +vamos a definir como def, función max, max + +00:13:50.779 --> 00:13:54.940 +de un vector x. Vamos a hacerlo con + +00:13:54.940 --> 00:13:58.060 +n vectores en general y vamos a hacer + +00:13:58.060 --> 00:14:01.279 +un return, llamamos a la función n p + +00:14:01.500 --> 00:14:04.855 +max y le damos de comer el vector + +00:14:04.855 --> 00:14:06.855 +x. Esto nos va a regresar el máximo + +00:14:06.855 --> 00:14:10.375 +elemento de nuestro vector. Vamos a comprobarlo. Por + +00:14:10.375 --> 00:14:20.230 +ejemplo, si nosotros evaluamos la función max con + +00:14:20.230 --> 00:14:25.590 +el vector uno coma cero coma uno coma + +00:14:25.590 --> 00:14:29.290 +dos, nos tendría que dar como salida justamente + +00:14:29.430 --> 00:14:31.910 +este dos. Vamos a ver qué nos arroja + +00:14:31.910 --> 00:14:42.895 +max. Max DNP array de el uno coma + +00:14:42.895 --> 00:14:46.970 +cero coma dos, y esto nos da exactamente + +00:14:47.030 --> 00:14:49.770 +el dos, que es el elemento máximo del + +00:14:50.230 --> 00:14:55.430 +vector. Ahora, vamos a comprobar que no cumple + +00:14:55.430 --> 00:14:57.910 +la la propiedad de la superposición y, por + +00:14:57.910 --> 00:15:00.845 +ende, no es lineal. Vamos a tomar los + +00:15:00.845 --> 00:15:05.405 +mismos vectores que habíamos tomado acá. Vamos a + +00:15:05.405 --> 00:15:11.185 +tomar x igual a uno coma menos uno, + +00:15:12.410 --> 00:15:14.490 +y hay que aclararlo como np array, no + +00:15:14.490 --> 00:15:19.529 +lo creamos como una lista. Y también hay + +00:15:19.529 --> 00:15:25.095 +que aclarar y igual a np. Array, y + +00:15:25.095 --> 00:15:30.455 +declaramos el menos uno coma uno. De igual + +00:15:30.455 --> 00:15:34.375 +manera, declaremos alfa y beta los vamos a + +00:15:34.375 --> 00:15:37.735 +escribir como a coma b igual a un + +00:15:37.735 --> 00:15:43.750 +medio coma un medio, porque así los estamos + +00:15:44.050 --> 00:15:49.030 +definiendo acá. Entonces, notemos qué nos da primero + +00:15:51.330 --> 00:16:00.235 +evaluar la combinación lineal en f. Entonces, lo + +00:16:00.235 --> 00:16:03.855 +que vamos a hacer es evaluar max en + +00:16:03.995 --> 00:16:26.615 +a por x más b por Ahora vamos + +00:16:26.615 --> 00:16:29.755 +a ver qué pasa si esta función la + +00:16:30.455 --> 00:16:32.855 +evaluamos como acá primero evaluamos la función y + +00:16:32.855 --> 00:16:58.305 +después multiplicamos por los escalares. Esto nos da + +00:16:58.305 --> 00:17:01.665 +un uno. Esto quiere decir que esto de + +00:17:01.665 --> 00:17:03.665 +aquí no es igual a esto, por lo + +00:17:03.665 --> 00:17:06.520 +tanto, la función max no cumple la propiedad + +00:17:06.520 --> 00:17:09.480 +de la superposición, por lo tanto, no es + +00:17:09.480 --> 00:17:12.859 +una función lineal. Entonces, ya dimos un contraejemplo + +00:17:13.560 --> 00:17:16.920 +en donde max no es una función lineal, + +00:17:16.920 --> 00:17:19.420 +y con esto ya demostramos que, en efecto, + +00:17:19.800 --> 00:17:22.635 +max no es lineal. Ahora, en el caso + +00:17:22.635 --> 00:17:25.194 +de los teoremas, tenemos que demostrar que siempre + +00:17:25.194 --> 00:17:27.835 +es verdad, verdad, no importa qué ángulos, por + +00:17:27.835 --> 00:17:30.554 +ejemplo, aquí nos estemos tomando, qué números estemos + +00:17:30.554 --> 00:17:32.794 +sumando en este en el caso de este + +00:17:32.794 --> 00:17:36.380 +teorema. Cuando queremos demostrar que algo no es + +00:17:36.380 --> 00:17:39.740 +verdad, es decir, queremos dar un contraejemplo, basta + +00:17:39.740 --> 00:17:42.300 +con que demos uno. Con uno solo basta, + +00:17:42.300 --> 00:17:45.420 +no tenemos que dar todos, porque al final + +00:17:45.420 --> 00:17:48.455 +el conjunto de r dos es infinito, entonces + +00:17:48.455 --> 00:17:52.991 +no acabaríamos nunca. Hasta aquí llega esta clase. + +00:17:53.771 --> 00:17:55.931 +Nos vemos en la próxima, en donde veremos + +00:17:55.931 --> 00:17:58.991 +las consideraciones finales y se quedarán tus ejercicios + +00:17:59.051 --> 00:18:01.871 +de esta sección. Hasta la próxima.