ML | Operaciones de álgebra lineal

Los principios del álgebra lineal son cruciales para comprender el concepto detrás del aprendizaje automático, así como el aprendizaje profundo, incluso muchas ideas luchan por crear un modelo matemático preciso, el álgebra lineal sigue siendo una herramienta importante para investigarlas. Álgebra le brinda una mejor comprensión de cómo los algoritmos realmente funcionan bajo el capó para que un desarrollador pueda tomar mejores decisiones y no pueda evitar aprender algunas de estas técnicas si quiere ser un profesional en Machine Learning o Deep Learning.

¿Qué es el Álgebra Lineal?
Es una rama de las matemáticas que permite definir y realizar operaciones sobre coordenadas de dimensiones superiores e interacciones planas de manera concisa. El álgebra lineal es una extensión del álgebra a un número indefinido de dimensiones. El álgebra lineal se refiere al enfoque en los sistemas de ecuaciones lineales. Es un tipo continuo de matemáticas y es aplicable en ciencia e ingeniería, ya que ayuda a modelar y simular fenómenos naturales de manera eficiente.

Antes de pasar a los conceptos de álgebra lineal, debemos comprender las siguientes propiedades:

Propiedad Asociativa: Es una propiedad en Matemáticas que establece que si a , b y c son objetos matemáticos entonces a + (b + c) = (a + b) + c en donde + es una operación binaria.
Propiedad Conmutativa: Es una propiedad en Matemáticas que establece que si a y b son objetos matemáticos entonces a + b = b + a en donde + es una operación binaria.
Propiedad Distributiva: Es una propiedad en Matemáticas que establece que si a , b y c son objetos matemáticos entonces a * (b + c)= (a * b) + (a * c) en donde * y + son operadores binarios.

A continuación se presentan algunos conceptos de álgebra lineal que se utilizan principalmente en la implementación de Machine Learning:

Escalar: Es una cantidad física descrita usando un solo elemento, tiene solo magnitud y no dirección. Básicamente, un escalar es solo un número.
```
Example: 
17 and 256
```
Vector: Es un objeto geométrico que tiene tanto magnitud como dirección, es una array de números ordenados y siempre están en una fila o columna. Un Vector tiene solo un índice, que puede referirse a un valor particular dentro del Vector.

Aquí V es un vector en el que e1 , e2 , e3 y e4 son sus elementos, y V[2] es e3 .
```
Example: 
[2, 3, 4] and [34, 53]
```
Operaciones:
```
p = [e1, e2, e3]
```
El producto de un escalar con un vector da el siguiente resultado:
```
p * 2 = [2 * e1, 2 * e2, 2 * e3]
```
cuando el escalar 2 se multiplica por un vector p entonces todos los elementos del vector p se multiplican por ese escalar. Esta operación satisface la propiedad conmutativa.
```
Example:
x = [1, 2]
x * 4 = [4, 8]
```

Array: Es una array 2D ordenada de números, símbolos o expresiones dispuestas en filas y columnas. Tiene dos índices, el primer índice apunta a la fila y el segundo índice apunta a la columna. Una Array puede tener múltiples números de filas y columnas.

Por encima de M hay una array 2D que tiene e1 , e2 , e3 y e4 como elementos, y M[1][0] es e3 .

Example:
2 3 6  and 56 12 
4 5 8      45 78
           34 67

Una array que tiene sus elementos diagonales izquierdos como 1 y otros elementos como 0 es una array Identidad .

Example:
1 0 
0 1 is 2D Identity Matrix.

1 0 0
0 1 0
0 0 1 is 3D Identity Matrix.

Operaciones:

Multiplicación de array escalar:
```
p = e1 e2 
    e3 e4
a is a scalar.
p * a = (a * e1)  (a * e2)
        (a * e3)  (a * e4)
```
Cuando el escalar a se multiplica por una array p entonces todos los elementos de la array p se multiplican por ese escalar. La multiplicación escalar-matricial es asociativa, distributiva y conmutativa.
```
Example:
x = 1 2 3
    4 5 6
x * 4 = 4  8  12
        16 20 24
```
Multiplicación de array vectorial:
```
p = e1 e2
    e3 e4
    e5 e6
q = a
    b
```
Multiplicar una array p con un vector q da el siguiente producto:
```
p * q = (e1 * a) + (e2 * b)
        (e3 * a) + (e4 * b)
        (e5 * a) + (e6 * b)
```
El número de filas de una array debe ser igual al número de elementos del vector, entonces solo estos pueden multiplicarse. La multiplicación Vector-Matrix es asociativa y distributiva pero no conmutativa.
```
Example:
m = 1 2  and n = 1
    3 4          2 
    5 6
then m * n = 5
             11
             17
```
Adición array-array:
```
m1 = a b  and m2 = p q 
     c d           r s
```
Para sumar arrays, las filas y columnas de las arrays deben ser iguales. La suma de la array m1 y m2 da el siguiente resultado:
```
m1 + m2 = (a + p) (b + q)
          (c + r) (d + s)
```
Cada elemento de la primera array se suma con el elemento respectivo de la otra array que tiene el mismo valor de fila y columna. La suma array-array es asociativa, distributiva y conmutativa.
```
Example:
1 2   5 5   6 7
2 1 + 5 5 = 7 6
1 2   5 5   6 7 
```
Resta array-array:
```
m1 = a b  and m2 = p q 
     c d           r s
```
Para poder restar arrays, las filas y columnas de las arrays deben ser iguales. La resta entre la array m1 y m2 da el siguiente resultado:
```
m1 - m2 = (a - p) (b - q)
          (c - r) (d - s)
```
Cada elemento de la primera array se resta con el elemento respectivo de la otra array que tiene el mismo valor de fila y columna. La suma array-array es asociativa, distributiva y conmutativa.
```
Example:
1 2   5 5   -4 -3
2 1 - 5 5 = -3 -4
1 2   5 5   -4 -3
```
Multiplicación Array-Array:
```
m1 = a b  and m2 = p q 
     c d           r s
```
Para multiplicar dos arrays, el número de columnas de la primera array debe ser igual al número de filas en la segunda array, el producto de la array m1 y m2 se da a continuación:
```
m1 * m2 = ((a * p) + (b * r))   ((a * q) + (b * s))  
          ((c * p) + (d * r))   ((c * q) + (d * s))
```
La multiplicación array-array es asociativa y distributiva pero no conmutativa.
```
Example:
1 3 2   1 3    11 10
4 0 1 * 0 1 =  9  14
        5 2
1 3 2   1    11
4 0 1 * 0 =  9 
        5 
1 3 2   3    10
4 0 1 * 1 =  14
        2 
```
Sean x1 , x2 y x3 arrays tales que x1 tiene un número de filas y b número de columnas y x2 tiene b número de filas y c número de columnas y x3 es el producto de x1 y x2 entonces, x3 tendrá un número de filas y c número de columnas. x1 * x2 = x3 en la que x3 tiene filas y c columnas .
Transposición:
La transposición de una array genera una nueva array en la que las filas se convierten en columnas y las columnas se convierten en filas de la array original.
```
m = a b
    c d
Transpose(m) = a c 
               b d  
```
Si A es una array y B es la transpuesta de la array A, entonces la transpuesta de la array B es la array original A.
B = Transponer (A) entonces, Transponer (B) = Transponer (Transponer (A)) = A
```
Example:
x = 1 2 3
Transpose of matrix x is 1
                         2 
                         3
```
La transposición de una array m*n dará una array n*m .
Inversa:
La inversa de una array es la array cuando se multiplica con la array original da como resultado la array Identidad. Si m es una array y n es la array inversa de m , entonces m*n = I , en la que represento la array Identidad.
```
Example:
m = 4 7 and inverse(m) =  0.6 -0.7  
    2 6                  -0.2 0.4
4 7  *  0.6 -0.7 = 1 0 
2 6    -0.2  0.4   0 1 
```

Tensor: Es un objeto algebraico que representa un mapeo lineal de objetos algebraicos de un conjunto a otro. En realidad, es una array 3D de números con un número variable de ejes, dispuestos en una cuadrícula regular. Un tensor tiene tres índices, el primer índice apunta a la fila, el segundo índice apunta a la columna y el tercer índice apunta al eje.

Aquí el tensor T tiene 8 elementos e1 , e2 , e3 , e4 , e5 , e6 , e7 y e8 en los que T[0][3][1] es e8 .

Publicación traducida automáticamente

Artículo escrito por riturajsaha y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta