Summary
This chapter demonstrates how to generate 2D arrays with a specific pattern—namely identity and rectangular matrices—using NumPy’s eye() function by specifying rows, columns, data type, and diagonal offset.

General domain of usage
Machine learning (e.g., weight initialization)

Net als bij 1D-arrays heeft **NumPy** aanmaakfuncties voor 2D-arrays. De meest gebruikte functie, de `eye()`-functie, wordt hier behandeld.

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()

De functie `numpy.eye()` maakt een **matrix** in de vorm van een 2D-array waarbij de elementen met **gelijke** rij- en kolomindex `1` zijn, terwijl alle andere elementen `0` zijn.

De twee belangrijkste parameters zijn `N` en `M`, die respectievelijk het aantal **rijen** en **kolommen** aangeven. De parameter `M` is optioneel, zodat je alleen `N` kunt opgeven om een vierkante `NxN`-matrix te maken.

Een vierkante matrix waarbij alle hoofddiagonalelementen gelijk zijn aan `1` en alle andere elementen gelijk zijn aan `0`, wordt een **identiteitsmatrix** genoemd.

Definitie

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}')

In het voorbeeld is een **identiteitsmatrix** gemaakt door alleen de parameter `N` op te geven en een **rechthoekige matrix** door zowel `N` als `M` te specificeren. Voor de **rechthoekige matrix** is ook de `dtype` ingesteld op `np.int8`, wat handig is bij het werken met alleen **gehele getallen** (`np.float64` is de standaardwaarde voor `dtype`).

De resulterende 2D-arrays zien er als volgt uit:

Wat betreft toepassingen wordt de functie `eye()` voornamelijk gebruikt om identiteitsmatrices te maken voor specifieke **lineaire algebra**-operaties en om matrices te initialiseren in **machine learning-algoritmen**.

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

Ontgrendel het volledige potentieel van Python's meest essentiële bibliotheek voor numerieke berekeningen, NumPy. Deze uitgebreide cursus is ontworpen om je van een basiskennis naar een gevorderd niveau van vaardigheid in NumPy te brengen. Of je nu data scientist, ingenieur, onderzoeker of ontwikkelaar bent, het beheersen van NumPy is essentieel voor efficiënte datamanipulatie, wetenschappelijk rekenen en machine learning.

Ontdek de toepassingen van NumPy en begrijp waarom het een van de populairste bibliotheken is voor numerieke berekeningen. Leer de verschillende manieren om arrays te maken en te initialiseren om efficiënt aan diverse databehoeften te voldoen.

Ontdek hoe u specifieke elementen en deelverzamelingen in NumPy-arrays kunt benaderen met behulp van indexnotatie. Leer om conditionele indexering toe te passen om gegevens te filteren en ontbrekende waarden efficiënt te beheren.

NumPy biedt veel ingebouwde functies voor het uitvoeren van veelvoorkomende arraybewerkingen. Leer hoe u deze tools kunt toepassen om gegevens efficiënt te transformeren, aggregeren en analyseren zonder repetitieve code te schrijven.

Leer hoe u wiskundige bewerkingen efficiënt uitvoert op NumPy-arrays. Pas deze bewerkingen toe om realistische problemen op te lossen en krijg een dieper inzicht in hoe gevectoriseerde berekeningen numerieke analyses versnellen.

Creatiefuncties voor 2D-Arrays

eye()

Oplossing