Jax-metal on Apple M-series GPUs is barely useable in my opinion. It's not possible to invert a matrix, for example, because Apple has not implemented the necessary triangular solve operator. It's also not possible to sample points from a normal distribution, because the Cholesky decomposition operator is not yet implemented. Apple hasn't responsed to both of these issues for the past year. It's difficult to take a numerical computing framework seriously if one cannot invert a matrix.
Not necessarily if you get rid of the energy in another way, right? You could perform hydrolysis to turn water into hydrogen + oxygen, and if you release hydrogen into the atmosphere it will just escape our atmosphere into space.
The only practical way to do such a thing would be with a giant mirror. There is no reason why earth cannot radiate energy back into space. A mirror is a good way to do that for the optical wavelengths. Most of the energy received by earth each day is in the optical spectrum and secondarily from the gravitational interaction of the earth-moon system. The moon we can't really do much about. But sunlight absolutely can be reflected.
A mirror would also be much more effective if part of some ring like structure orbiting the earth, as most of the energy would never enter encounter earth's atmosphere in the first place.
It's naive to think you can compare vectors without any sort of prior on what this relationship might look like. Hoeffding's D cannot effectively capture relationships between time-shifted series that the (generalised) cross correlation can. Nor can it identify patterns in conditional heteroskedasticity. You will always need to impose some sort of prior when comparing vectors, and Hoeffding's D is rarely the best choice.
In my experience, PyMC leads to models that are orders of magnitudes slower than equivalent models written in JAGS. Profiling is also extremely tedious, and there is no section in the PyMC docs that touches upon model performance.
I really like PyMC's API, but as soon as you move towards bigger datasets JAGS or Stan seem to be the only practical options.
PyMC has a pretty active community where we help people with questions like these. Its hard to come up with one doc as folks have different hardware, datasets, models etc. I hope though you'll the devs and community to be friendly though!
For models with >100 parameters, there are theoretical reasons for why JAGS can fail badly. It has to do with the mixing time of Gibbs samplers versus Hamiltonian Monte Carlo.
You might be fine with DisplayLink and two monitors, however in my experience DisplayLink with an M1 and four external monitors was nearly impossible to use because of the input lag. Sometimes the entire DisplayLink driver would crash. I bought an M3 Max instead, there is no robust alternative.
I'm using displaylink and get a daily display freeze about 1h after the first wake-up of the day. The issue is open for over a year now and I'm effectively ignored.
Even when it works, the lag is noticeable. Would not recommend going that way.
I immediately tried to find a comparison with ARIMA as well and was disappointed. It's difficult to take this paper seriously when they dismiss a forecasting technique from the 70's because of "extensive training times".
Even then, 500 years of daily data is less than 200k observations, most of which are meaningless for predicting the future. Less than 16B seconds of data. Regression might not handle directly, but linear algebra tricks are still available.
Newton's method is an algorithm you can use to minimise/maximise/find the root of a differentiable function very quickly if you start with a reasonable guess. There are many variants on Newton's method, e.g. BFGS that does not require the hessian (/2nd order derivative) of the function. A pitfall of Newton's method is that it does not find the global minimum per se, it might just converge to a local minimum if this local minimum is "closer" to your initial guess. Some variants of Newton's method allow you to avoid this pitfall, but they are slow in practice.
This seems to be another variant that claims to find the global minimum quicker than other existing methods. I am not experienced enough to verify this claim. I am also not sure how this new algorithm performs in practice; in theory, ellipsoid methods are a lot more efficient than simplex methods for optimising convex functions, while in practice simplex methods are usually an order of magnitude faster. So take this result with a grain of salt.
To clarify, "global" in this context refers to global convergence (as in, it won't diverge no matter the starting point), not global optima. They assume a convex function, i.e. only a single minimum. The paper is unrelated to avoiding local minima.
There is no way of ensuring that you have found a global minimum if the function is not convex, or if you don’t make equivalent assumptions, in the general case (if the domain of the function is continuous, and/or infinite).
If you don’t make assumptions, you would need to consider every single point of the domain, and there is an infinite number of them. The job gets easier the more assumptions you make about the continuous, differentiable, and monotonous character of the function.
Statisticians and mathematicians call them dimensions, machine learning engineers call them "features". Statisticians and mathematicians usually interpret observations as vectors in n-dimensional space, which leads to some interesting geometric results. Hence the term dimension, we do mathematics with them as if they were actual points in some high-dimensional space. Degrees of freedom are something a bit more nuanced that are of use when you start to do specific statistical tests, and they do not have to be exactly equal to your amount of dimensions.
Immersed apparently uses the same technique as BetterDummy to create virtual displays. I don't know if without a subscription BetterDummy created additional virtual displays show up in Immersed (as I have Elite), but for sure, BetterDummy created displays show up in Immersed.
[1]: https://github.com/google/jax/issues/16321 [2]: https://github.com/google/jax/issues/17490