Summary  
This chapter introduces NumPy’s eye() function for creating two-dimensional identity and rectangular matrices by specifying rows, columns, data type, and diagonal offset.

General domain of usage  
Linear algebra operations

De manera similar a los arreglos unidimensionales, **NumPy** dispone de funciones de creación para arreglos bidimensionales. Se abordará la más común, la función `eye()`.


This video explores creation functions for 2D arrays in NumPy, focusing on the numpy.eye() function. You'll learn how to create identity and rectangular matrices, understand key parameters like N (rows), M (columns), and dtype, and see practical code demonstrations. The video also highlights real-world applications in linear algebra and machine learning, such as initializing weights and constructing identity matrices for matrix operations.

## eye()

La función `numpy.eye()` crea una **matriz** en formato de arreglo bidimensional donde los elementos con índices de fila y columna **iguales** son `1`, mientras que todos los demás elementos son `0`.

Los dos parámetros más importantes son `N` y `M`, que especifican el número de **filas** y **columnas** respectivamente. El parámetro `M` es opcional, por lo que se puede especificar solo `N` para crear una matriz cuadrada de tamaño `NxN`.

Una matriz cuadrada con todos los elementos de la diagonal principal iguales a `1` y todos los demás elementos iguales a `0` se denomina **matriz identidad**.

Definición

import numpy as np
# Creating a 2x2 identity matrix
identity_matrix = np.eye(2)
print(f'2x2 identity matrix:\n{identity_matrix}')
# Creating a 4x3 matrix with np.eye()
rectangular_matrix = np.eye(4, 3, dtype=np.int8)
print(f'4x3 matrix:\n{rectangular_matrix}')

En el ejemplo, se creó una **matriz identidad** especificando solo el parámetro `N` y una **matriz rectangular** especificando tanto `N` como `M`. También se estableció el `dtype` en `np.int8` para la **matriz rectangular**, lo cual resulta útil al trabajar únicamente con **enteros** (`np.float64` es el valor predeterminado para `dtype`).

Los arreglos 2D resultantes son los siguientes:


En cuanto a aplicaciones, la función `eye()` se utiliza principalmente para crear matrices identidad para operaciones específicas de **álgebra lineal** y para inicializar matrices en **algoritmos de aprendizaje automático**.

import unittest
import importlib.util
import numpy as np
import io
from contextlib import redirect_stdout


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        # Імпортуємо user_code
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        cls.m = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(cls.m)
        cls.module_path = spec.origin

        # Очікуваний результат
        cls.exp_matrix = np.eye(5, 2, dtype=np.int8)

    def test_matrix_properties(self):
        """1–3. Check that matrix is created correctly with np.eye(5, 2, dtype=np.int8)"""
        ok = hasattr(self.m, "matrix")
        arr = getattr(self.m, "matrix", None)

        type_ok = isinstance(arr, np.ndarray)
        shape_ok = type_ok and arr.shape == (5, 2)
        dtype_ok = type_ok and arr.dtype == np.int8
        val_ok = type_ok and np.array_equal(arr, self.exp_matrix)

        # Значення по головній діагоналі мають бути 1, решта — 0
        diag_ok = type_ok and np.all(np.diag(arr[:2, :2]) == 1)
        zero_ok = type_ok and np.all(arr[np.where(arr != np.eye(5, 2))] == 0)

        _dynamic_test(
            self,
            ok and type_ok and shape_ok and dtype_ok and val_ok and diag_ok and zero_ok,
            "matrix created correctly",
            "matrix incorrect or has wrong properties",
        )

    def test_matrix_printed(self):
        """Перевіряємо, що matrix виводиться"""
        f = io.StringIO()
        with open(self.module_path, "r", encoding="utf-8") as file:
            code = file.read()
        with redirect_stdout(f):
            exec(code, {})
        output = f.getvalue().strip()

        # Має бути надруковано хоча б одну «1» та «0»
        printed_ok = "1" in output and "0" in output

        _dynamic_test(
            self,
            printed_ok,
            "matrix printed correctly",
            "matrix not printed or printed incorrectly",
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Desbloquea todo el potencial de la biblioteca más esencial de Python para el cálculo numérico, NumPy. Este curso integral está diseñado para llevarte desde un nivel principiante hasta un nivel avanzado de competencia en NumPy. Ya seas científico de datos, ingeniero, investigador o desarrollador, dominar NumPy es fundamental para la manipulación eficiente de datos, el cálculo científico y el aprendizaje automático.

Explora las aplicaciones de NumPy y comprende por qué es una de las bibliotecas más populares para el cálculo numérico. Aprende las diferentes formas de crear e inicializar arreglos para manejar diversas necesidades de datos de manera eficiente.

Descubre cómo acceder a elementos específicos y subconjuntos en arreglos de NumPy utilizando la notación de índices. Aprende a aplicar indexación condicional para filtrar datos y gestionar valores faltantes de manera eficiente.

NumPy ofrece muchas funciones integradas para realizar operaciones comunes con arreglos. Aprenda cómo aplicar estas herramientas para transformar, agregar y analizar datos de manera eficiente sin escribir código repetitivo.

Aprende a realizar operaciones matemáticas de manera eficiente en arreglos de NumPy. Aplica estas operaciones para resolver problemas del mundo real y adquiere una comprensión más profunda de cómo los cálculos vectorizados aceleran el análisis numérico.

Funciones de Creación para Arreglos 2D

eye()

Solución