Tous les défis
Facile 0 résolus 0 % de réussite

Multiplication de matrices

Multipliez deux matrices, l'opération derrière chaque couche d'un réseau de neurones.

Ce que vous allez apprendre

  • Multiplier des matrices ligne par colonne
  • Vérifier que les dimensions sont compatibles
  • Comprendre pourquoi les couches sont des produits de matrices

Problème

Les couches des réseaux de neurones, l'attention et l'essentiel de l'apprentissage automatique se ramènent à la multiplication de matrices. Pour une matrice A de taille n × k et une matrice B de taille k × m, le produit C = A × B est de taille n × m, et chaque coefficient est le produit scalaire d'une ligne de A et d'une colonne de B :

C[i][j] = A[i][0] × B[0][j] + A[i][1] × B[1][j] + … + A[i][k-1] × B[k-1][j]

Implémentez matmul(a, b).

Entrée

a : une matrice n × k.

b : une matrice k × m (son nombre de lignes égale le nombre de colonnes de a).

Sortie

Renvoyez la matrice produit n × m.

Contraintes

1 ≤ n, k, m ≤ 50

-100 ≤ chaque valeur ≤ 100

Exemples

Exemple 1
Entrée :
a = [
    [1.0, 2.0],
    [3.0, 4.0]
]
b = [
    [5.0, 6.0],
    [7.0, 8.0]
]

Sortie attendue :
expected = [
    [19.0, 22.0],
    [43.0, 50.0]
]
Entrée :
std::vector<std::vector<double>> a = {
    {1.0, 2.0},
    {3.0, 4.0}
};
std::vector<std::vector<double>> b = {
    {5.0, 6.0},
    {7.0, 8.0}
};

Sortie attendue :
std::vector<std::vector<double>> expected = {
    {19.0, 22.0},
    {43.0, 50.0}
};
Entrée :
double[][] a = new double[][] {
    new double[] {1.0, 2.0},
    new double[] {3.0, 4.0}
};
double[][] b = new double[][] {
    new double[] {5.0, 6.0},
    new double[] {7.0, 8.0}
};

Sortie attendue :
double[][] expected = new double[][] {
    new double[] {19.0, 22.0},
    new double[] {43.0, 50.0}
};

Explication

C[0][0] = 1×5 + 2×7 = 19, C[0][1] = 1×6 + 2×8 = 22, C[1][0] = 3×5 + 4×7 = 43 et C[1][1] = 3×6 + 4×8 = 50.

Exemple 2
Entrée :
a = [
    [1.0, 0.0, 2.0]
]
b = [
    [3.0],
    [4.0],
    [5.0]
]

Sortie attendue :
expected = [
    [13.0]
]
Entrée :
std::vector<std::vector<double>> a = {
    {1.0, 0.0, 2.0}
};
std::vector<std::vector<double>> b = {
    {3.0},
    {4.0},
    {5.0}
};

Sortie attendue :
std::vector<std::vector<double>> expected = {
    {13.0}
};
Entrée :
double[][] a = new double[][] {
    new double[] {1.0, 0.0, 2.0}
};
double[][] b = new double[][] {
    new double[] {3.0},
    new double[] {4.0},
    new double[] {5.0}
};

Sortie attendue :
double[][] expected = new double[][] {
    new double[] {13.0}
};

Explication

Une matrice 1 × 3 multipliée par une matrice 3 × 1 donne une matrice 1 × 1 : 1×3 + 0×4 + 2×5 = 13.

Références

Ce défi a été adapté pour CodeUtility. Suivez l'énoncé et les contraintes ci-dessus.

Apprenez des autres

Solutions de la communauté

Aucune solution publiée pour l'instant. Résolvez ce défi pour partager la première.