float32 is a 32 bit number - float64 uses 64 bits.

That means that float64’s take up twice as much memory - and doing operations on them may be a lot slower in some machine architectures.

However, float64’s can represent numbers much more accurately than 32 bit floats.

They also allow much larger numbers to be stored.

For your Python-Numpy project I'm sure you know the input variables and their nature.

To make a decision we as programmers need to ask ourselves

1. What kind of precision does my output need?
2. Is speed not an issue at all?
3. what precision is needed in parts per million?

A naive example would be if I store weather data of my city as [12.3, 14.5, 11.1, 9.9, 12.2, 8.2]

Next day Predicted Output could be of 11.5 or 11.5164374

do your think storing float 32 or float 64 would be necessary?

np.float32(a) is equivalent to np.array(a, dtype=np.float32). it's a data type of some size.

a = [1, 2, 3]                      # a(list,len=3): [1, 2, 3]
b = np.float32(a)                  # b(numpy.ndarray,s=(3,),dtype=float32): [1.00, 2.00, 3.00]
c = np.array(a, dtype=np.float32)  # c(numpy.ndarray,s=(3,),dtype=float32): [1.00, 2.00, 3.00]

a = [100, 200, 300]             # a = [100, 200, 300]
b = np.uint8(a)                 # b(numpy.ndarray,s=(3,),dtype=uint8): [100, 200, 44]
c = np.array(a, dtype=np.uint8) # c = np.array(a, dtype=np.uint8)
d = np.int32(a)                 # d(numpy.ndarray,s=(3,),dtype=int32): [100, 200, 300]

Notice on the second example that an unsigned int8 is not big enough for the number 300 - hence overflow (max val for uint8 is 255).

Data type-wise numpy floats and built-in Python floats are the same, however boolean operations on numpy floats return np.bool_ objects, which always return False for val is True. Example below:

In [1]: import numpy as np
   ...: an_np_float = np.float32(0.3)
   ...: a_normal_float = 0.3
   ...: print(a_normal_float, an_np_float)
   ...: print(type(a_normal_float), type(an_np_float))

0.3 0.3
<class 'float'> <class 'numpy.float32'>

Numpy floats can arise from scalar output of array operations. If you weren't checking the data type, it is easy to confuse numpy floats for native floats.

In [2]: criterion_fn = lambda x: x <= 0.5
   ...: criterion_fn(a_normal_float), criterion_fn(an_np_float)

Out[2]: (True, True)

Even boolean operations look correct. However the result of the numpy float isn't a native boolean datatype, and thus can't be truthy.

In [3]: criterion_fn(a_normal_float) is True, criterion_fn(an_np_float) is True
Out[3]: (True, False)

In [4]: type(criterion_fn(a_normal_float)), type(criterion_fn(an_np_float))
Out[4]: (bool, numpy.bool_)

According to this github thread, criterion_fn(an_np_float) == True will evaluate properly, but that goes against the PEP8 style guide.

Instead, extract the native float from the result of numpy operations. You can do an_np_float.item() to do it explicitly (ref: this SO post) or simply pass values through float().