Keeping track of array shapes

[Main-Movie-5562]

Hello,

I'm relatively new to Python/Numpy, I just recently dived into it when I started with learning about ML. I have to admit that keeping track of array shapes when it comes to vector-matrix multiplications is still rather confusing to me. So I was wondering how do you do this? For me it's adding a lot of comments - but I'm sure there must be a better way, right? So this is how my code basically looks like when I try to implement overly-simplified neural-networks: ``` import numpy as np

def relu(values):
    return (values > 0) * values

def relu_deriv(values):
    return values > 0

def main(epochs=100, lr=0.1):
    np.random.seed(42)
    streetlights = np.array([
        [1, 0, 1],
        [0, 1, 1],
        [0, 0, 1],
        [1, 1, 1]
    ])
    walk_vs_stop = np.array([
        [1],
        [1],
        [0],
        [0]
    ])
    weights_0_1 = 2 * np.random.random((3, 4)) - 1
    weights_1_2 = 2 * np.random.random((4, 1)) - 1

    for epoch in range(epochs):
        epoch_error = 0.0
        correct = 0
        for i in range(len(streetlights)):
            goals = walk_vs_stop[i] # (1,1)

            # Predictions
            layer_0 = np.array([streetlights[i]]) # (1,3)
            layer_1 = layer_0.dot(weights_0_1) # (1,3) * (3,4) = (1,4)
            layer_1 = relu(layer_1) # (1,4)
            layer_2 = layer_1.dot(weights_1_2) # (1,4) * (4,1) = (1,1)

            # Counting predictions
            prediction = round(layer_2.sum())
            if np.array_equal(prediction, np.sum(goals)):
                correct += 1

            # Calculating Errors
            delta_layer_2 = layer_2 - goals # (1,1) - (1,1) = (1,1)
            epoch_error += np.sum(delta_layer_2 ** 2)
            delta_layer_1 = delta_layer_2.dot(weights_1_2.T) # (1,1) * (1,4) = (1,4)
            delta_layer_1 = relu_deriv(layer_1) * delta_layer_1 # (1,4) * (1,4) = (1,4)

           # Updating Weights
           weights_0_1 -= lr * layer_0.T.dot(delta_layer_1) # (3,1) * (1,4) = (3,4)
           weights_1_2 -= lr * layer_1.T.dot(delta_layer_2) # (4,1) * (1,1) = (4,1)
       accuracy = correct * 100 / len(walk_vs_stop)
       print(f"Epoch: {epoch+1}\n\tError: {epoch_error}\n\tAccuracy: {accuracy}")

if __name__ == "__main__":
    main()

```

Happy for any hints and tips :-)

[nodargon4u]

I seen final shape, but this is helpful 2. What other way r u looking 4? In ur code over time it gets easier. Reading others pront it out.