How is it possible that np.mean takes so much longer than looping and calculating the mean regularly?

I've been building a neural network that uses a binary classification, and I noticed its running really slow. The code is:

predictions = self.neural_network.propagate(X_train)
rounded_predictions = (predictions > 0.5).astype(int)
accuracy = np.mean(rounded_predictions == y_train)

where x_train is of shape (16000,16) and y_train is of shape (16000,) <br>
When checking where the bottleneck is, I found that calculating accuracy using np.mean took an average of 0.55 seconds. I couldn't figure out what is taking it so long so i tried calculating it in a different way:

def compute_accuracy_score(y_train, predictions):
    """
        Calculates the accuracy score of the predictions made by the network.
        If a prediction matches its true label, it increments the count of correct predictions.
        The accuracy score is the correct predictions divided by the total predictions.
    """
    num_samples = len(y_train)
    correct_predictions = 0

    # If the prediction is correct, increment the count of correct predictions
    for true_label, predicted_label in zip(y_train, predictions):
        if true_label == predicted_label:
            correct_predictions += 1

    # Compute accuracy as the ratio of correct predictions to total number of samples
    accuracy = correct_predictions / num_samples
    return accuracy

This code ran it in an appropriate sub 0.01 seconds.
I don't understand why the np.mean took so much time compared to the simple loop.

This is the code I wrote to check the run time:

        def calculate_fitness(self):
            predictions = self.neural_network.propagate(X_train)
            rounded_predictions = (predictions > 0.5).astype(int)
            start_time = time.time()
            accuracy1 = compute_accuracy_score(y_train, rounded_predictions)
            end_time = time.time()
            print('Time to calculate fitness using compute accuracy:', end_time - start_time, 'seconds')
            start_time = time.time()
            accuracy = np.mean(rounded_predictions == y_train)
            end_time = time.time()
            print('Time to calculate fitness using np.mean:', end_time - start_time, 'seconds')
            print('Accuracy:', accuracy, 'Accuracy1:', accuracy1)
            self.fitness = round(float(accuracy), 4)

The accuracy isnt the same, neither is the run time: <br>
Time to calculate fitness using compute accuracy: 0.022114276885986328 seconds <br>
Time to calculate fitness using np.mean: 0.6563560962677002 seconds <br>
Accuracy: 0.559151625 Accuracy1: 0.6015625 <br>
Time to calculate fitness using compute accuracy: 0.021242141723632812 seconds <br>
Time to calculate fitness using np.mean: 0.6553714275360107 seconds <br>
Accuracy: 0.441705 Accuracy1: 0.398875 <br>

I found the problem. I was using nparray of size (16000,1) which was translated to a 2D array for np.mean. However after using flatten() to get it to (16000,) it produced faster run times.

Are you sure you are not including the model's time to compute the predictions? Here:

predictions = self.neural_network.propagate(X_train)

Because I ran the following snippet on my laptop with larger dimensions and still the process time is around 4 seconds.

_s = time.time()
a = np.random.rand(160000000, 1)
b = np.random.rand(160000000, 1)
_round = (b > 0.5).astype(int)
c = np.mean(_round == b)
_e = time.time() 

Are you sure you are not accounting the time it takes to generate the predictions from your model inside the latency of the first method?

I have tried replicating your results, but I am seeing that the first method is 100x faster. Falling in the expectation range for a vectorized vs non-vectorized benchmark. See: