Double-precision calculations are significantly slower or more expensive than single-precision calculations. For example, the NVidia Tesla which performs well on doubles is much more expensive then regular GPU.
At the same time I do not know about machine learning cases where double-precision is really needed. Currently I think that 64-bit floats are needed by the model only in case then it is over-fitted. In other words doubles are needed only by "bad" models with bad generalization.
I am not an expert in machine learning, but I can outline the considerations that are relevant.
The numerical calculations in machine learning are generally linear algebra -- either solving linear systems or linear least squares. For both types of problems, there are well-known backward-stable methods, so I will assume you are using a backward-stable algorithm. Then you should expect an error of roughly $\kappa \epsilon$, where $\kappa$ is the condition number of the problem and $\epsilon$ is unit roundoff.
For the linear system $Ax=b$, you have $\kappa = \|A\| \|A^{-1}\| = \kappa(A)$, the condition number of the matrix $A$. For the least squares problem, the condition number can fall anywhere in the range $[\kappa(A),\kappa^2(A)]$; see e.g. the text of Trefethen & Bau for details.
Thus for linear systems, single precision will be sufficient as long as $\kappa(A)$ is much less than $10^7$. For least squares, you may already be in trouble when $\kappa(A)\approx 10^3 - 10^4$. For large datasets, those are not very large condition numbers. So it certainly seems plausible that you may need double precision.
Perhaps it's better to say that it depends on the nature (details) of the algorithm and linear algebra implementation.
More critically, while deep neural networks (DNN) have become widely popular, there are many other valuable techniques offered by machine learning. Thus, this question requires an answer that caters to both - ML in general and DNN in specifics.
Additionally, the paradigms of machine learning can be divided into practitioners and scholars. Practitioners are concerned with delivering task performance, whereas scholars are interested in seeking answers and giving advices via investigations and numerical analysis. Scholars may apply numerical techniques to machine learning algorithms in ways that practitioners won't; this is why double-precision may sometimes be involved in scholastic research.
Deep neural network, in practice, does not involve matrix inversion at all. The main algorithm involved is backpropagation. The gradient is computed after each forward pass; it is then scaled with the step size parameter and added back to the parameter matrices on each layer. Typically single precision is good for training, and inference can do with very low precisions. Typically the "adaptive mixed precision" technique is used in DNN. Typically, double precision does not improve DNN task accuracy at all when compared to single precision.
That said, singular value decomposition (SVD) is an option (choice) in the implementation of a technique called Low-Rank Adaptation (LoRA), the latter being well known for cost-effective fine-tuning of deep neural network large language models (closely related to the Transformer architecture). Rather than performing the steps in a high floating point precision, much of the engineering innovation went into modifying the SVD algorithm such that a reasonable approximation can be derived using the lowest possible floating point precision. In other words, whenever a speed-accuracy tradeoff happens, a lot of engineering effort is committed in order to enable a variety of middle ground approaches.
Outside of DNN, there are still many other machine learning algorithms that are not based on neural networks, and those might need to use a higher precision because they are based on different linear algebra techniques. The least squares method is probably the best well-known example.
Another relevant concern is numerical reproducibility. In DNN, numerical reproducibility is not highly valued. Instead, practitioners are fundamentally more concerned about replicating the task performance (accuracy) when a model is trained with a specific data set, a carefully described DNN architecture, and a detailed description of the training process. Training with stochastic gradient descent (SGD), minibatch, and data augmentation (data perturbations and alterations intended to make the model more task-robust) already involves tons of randomization; DNN practitioners are far more concerned about these stochastic techniques leading to a DNN model with good task performance (e.g. correctly classifying an object and its bounding box, without requiring subpixel accuracy) than the numerical reproducibility of the trained model parameters.
I've heard that KL divergence can be used to find an accurate approximation between a layer implemented with higher precision and a layer with lower precision, even when nonlinearity (e.g. multiple layers of DNN) is involved. This technique is often implemented into DNN frameworks to allow speed-accuracy tradeoffs. Unfortunately, I'm not familiar with these details.
I think you're right that double precision is not needed usually.
As a proxy, Apple's Metal framework doesn't support doubles at all, and it's being billed as a compute framework with Apple-provided functions for machine learning.
Info about Metal data types: https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
