mu | The μ css framework — a 1 ko css file | Theme library

for MDN model , the likelihood for each sample has to be calculated with all the Gaussians pdf , to do that I think you have to reshape your matrices ( y_true and mu) and take advantage of the broadcasting operation by adding 1 as the last dimension . e.g:

You're running out of heap memory in your node server. It might be because there's some statement that uses a lot of memory. You can try to find that or you can try to increase node memory like this.

This is what I achieved:

I'm not entirely sure if you wanted x to range from [-pi,pi] or [0,2pi]. If you want the range [0,2pi] instead, just comment out the lines ax.set_xlim and ax.set_xticks.

Try to add NODE_OPTIONS as key and --max_old_space_size=1024 in Config Vars under project settings

NODE_OPTIONS --max_old_space_size=1024 value.

I've found this in https://bismobaruno.medium.com/fixing-memory-heap-reactjs-on-heroku-16910e33e342

This is a two-part question:

• what priors should I use for a multivariate random effect where the likelihood is concentrated at small values? (I am assuming that this is the reason you are looking for an alternative to the default inverse Wishart priors) [more suitable for CrossValidated]
• which of these are available in MCMCglmm, and how do I implement them there? [good for Stack Overflow]

The general trick is to decompose the covariance matrix into a multivariate component (the correlation matrix or inverse correlation matrix or something) and a vector of scaling parameters for the standard deviations (or inverse standard deviations); Lemoine suggests U(0,100) for the scaling priors, which I think is bad (why flat? I can't get to the precise page of Gelman and Hill 2007 where they discuss which distribution to use for scaling priors ... but I would be a little surprised if they actually recommended a uniform distribution on the variance scale ...)

update having actually looked at your code (!): I think you're doing the right thing, except that nu=0.002 seems really extreme; see end for that discussion.

This is basically what MCMCglmm does, but it uses a different (IMO better) choice for the scaling priors. It sounds scary:

These priors are all from the non-central scaled F-distribution, which implies the prior for the standard deviation is a non-central folded scaled t-distribution (Gelman, 2006).

but it boils down to choosing four parameters, only two of which you really have to think about.

• V: the prior mean variance (or the prior mean covariance matrix, if you have a multivariate random effect term). According to the course notes, "without loss of generality V can be set to one" (or in the case of a multivariate model, to an identity matrix)
• alpha.mu: we almost always want this to be zero (or as in your example, a vector of zeros); that way the prior for the standard deviation will be a Student t distribution. (There may be a use case for alpha.mu != 0, but I've never run across it.)
• alpha.V: with V set to 1 (or an identity matrix), this is the prior mean of the covariance matrix. A diagonal matrix with a reasonable scale for your problem is a good choice
• nu: the shape parameter; as nu → ∞ we get a half-Normal prior for the standard deviations, with nu=1 we get a Cauchy distribution. Smaller values have fatter tails (less conservative/allowing broader samples, but also giving more danger of weird sampling behaviour in the tails).

For the univariate case Hadfield says the t prior with V=1 is

It sounds like you're confusing modules you install on the machine running Visual Studio Code and modules you install in Micropython on the ESP32.

They're totally separate.

Python on your Windows machine can use venv.

MicroPython doesn't use venv at all (there apparently is a clone of venv for MicroPython but it's not readily apparent what it does or why or how you'd use it). It is a completely separate instance of Python from the one on your Windows machine, and it doesn't operate the same way. Modules you install under venv won't be visible or usable by MicroPython. Numpy in particular is not available for MicroPython.

Many modules need to be written specially to work with MicroPython. MicroPython isn't running in a powerful operating system like Windows, MacOS or Linux. It's running in a highly constrained environment that lacks much of the functionality of those operating systems, and that has extremely little memory and storage compared to them. You can't expect that a module written for regular Python will just work on MicroPython (and likewise, many MicroPython modules use hardware features like I2C or SPI access that may not be available on more powerful, general purpose computers).

Only modules available with upip will be available for MicroPython. They'll need to be installed in the instance of MicroPython running on the ESP32, not in the instance of Python running under Windows. They're two, totally separate instances of Python.

If you take a look at the intl-tel-input documentation regarding Initialisation Options. There is an option called excludeCountries.

We can modify your initialisation code to include this option to exclude China:

From the data you've provided, it's impossible to tell why you're running out of memory.

Maybe the working set (i.e. the amount of stuff that you need to keep around at the same time) just happens to be larger than your current heap limit; in that case increasing the limit would help. It's easy to find out by trying it, e.g. with --max-old-space-size=8000 (megabytes).

Maybe there's a memory leak somewhere, either in your own code, or in one of your third-party modules. In other words, maybe you're accidentally keeping objects reachable that you don't really need any more.

If you provide a repro case, then people can investigate and tell you more.

Side notes:

• according to your output, heap memory consumption is growing to ~4 GB; not sure why you think it tops out at 1.2 GB.
• it is never necessary to invoke global.gc() manually; the garbage collector will kick in automatically when memory pressure is high. That said, if something is keeping old objects reachable, then the garbage collector can't do anything.