seed1 | Seed Framework is a multiplatform C 2D game development | Application Framework library

Why do i get same data with diffirent seed

All seed values don't necessarily produce unique sequences.

In the standard library implementation that you use, the seeds that you chose happen to produce the same sequence with the given random engine. This is likely because 0 happens to be special for that particular engine.

In case you're using libstdc++, the behaviour that you observe is explained by this implementation:

Thanks to missuse's comment, his marvellous tutorial (Tuning a stacked learner) and mb706's comments I think I could solve my question.

Replace "classif.cv_glmnet" with "classif.glmnet"

With recent versions, you can make multiple random generators. See the docs.

To illustrate, make 2 with the same seed:

Provided that the number of seeds you generate does not come close to exhausting the possible combinations, what you can do is a shuffle of the whole list of numbers that you then break down in chunks of the pool size. Then keep track of the pools used so far and generate another shuffle when you have a conflict.

This can be done in a generator function so that you don't need to predetermine the number of seeds you're going to generate:

It's a compilation flag, like -DCORE_DEBUG.

In some build environments you can enable/disable these as part of your build profile.

Since you only care about the number, there is no need to convert the value to string:

Since your program is working correctly on CPU but not on the GPU it could mean that you are exceeding the GPU TDR (Timeout Detection and Recovery) timer.

A cause for the Abort trap:6 error when doing computations on the GPU is locking the GPU into computation mode for too much time (a common value seems to be 5 seconds but I found contradicting resources on this number). When this occurs the watchdog will forcefully stop and restart the graphic driver to prevent the screen being stuck.

There are a couple possible solutions to this problem:

1. Work on a headless machine

Most (if not all) OS won't enforce the TDR if no screen is attached to them

1. Switch GPU mode

If you are working on an Nvidia Tesla GPU you can check if it's possible to switch it to Tesla Compute Cluster mode. In this mode the TDR limit is not enforced. There may be a similar mode for AMD GPUs but I'm not sure.

1. Change the TDR value

This can be done under Windows by editing the TdrDelay and TdrDdiDelay registry keys under HKEY_LOCAL_MACHINE -> SYSTEM -> CurrentControlSet -> Control -> GraphicsDrivers with a higher value. Beware to not put a number too high or you won't be able to know if the driver has really crashed.

Also take note that graphic drivers or Windows updates may reset these values to default.

Under Linux the TDR should already be disable by default (I know it is under Ubuntu 18 and Centos 8 but I haven't tested on other versions/distros), if you have problems anyway you can add Option Interactive "0" in your Xorg config like stated in this SO question

Unfortunately I don't know (and couldn't find) a way to do this on MacOS, however I do know that this limit is not enforced on a secondary GPU if you have it installed in your MacOS system.

1. Split your work in smaller chunks

If you can manage to split your computation into smaller chunks you may be able to not surpass the TDR timer (E.G. 2 computations that take 4s each instead of a single 8s one), the feasibility of this depends on what your problem is and may or may not be an easy task though.

I ran your code in colab, but I didn't face any problem like you. You can check my notebook here. It may be your python environmental error due to version. You can check the colab version of packages with yours. In colab tensorflow and keras version is given,

Also, I implemented it in your tf & keras version and solve your issue. You can check it here. Hope, your problem is solved. Your problem was you was using num_out_channels / 2 , you should use num_out_channels // 2 (integer not float).

The problem is not using the GPU, it is that the GPU ran out of memory. It is probably because the network size it too big to handle.

please note that your input is of size 48x48x1, which means that the output of the last Conv layer(after 4 Pooling steps) is of size 3x3x512. This layer is connected to a Dense layer with 4096, which means it has 3x3x512x4096 parameters. Then the last layer is additional 4096 neurions, which means additional 4096x4096 parameters. In total you have more than 36M parameters only in the last 2 layers. Then you connect it to the final layer in the size of number of classes, which is additional 4096xnum_classes parameters (which may be a lot, that depends on the number of classes you have).

So first try to reduce the number of neurons in the Dense layers, and in addition you maybe use to mach filters in your last convolution layers. A typical size of an "embedding" vector which uses for the final linear classification is 128-512, depends on the problem and the given data.