handwritten | Multiple fonts merged to together to diversify handwritten | User Interface library

Understand the dataset:

1. the size of the image is 32 x 32
2. there are 46 different characters/alphabets

You could load image, convert to grayscale, resize to (28,28)
and convert to train array with one example, and use it with fit()

Summary: don't use #pragma GCC optimize. Use -O3 on the command line instead, and you'll get the behavior you expect.

GCC's documentation on #pragma GCC optimize says:

Each function that is defined after this point is treated as if it had been declared with one optimize(string) attribute for each string argument.

And the optimize attribute is documented as:

The optimize attribute is used to specify that a function is to be compiled with different optimization options than specified on the command line. [...] The optimize attribute should be used for debugging purposes only. It is not suitable in production code. [Emphasis added, thanks Peter Cordes for spotting the last part.]

So, don't use it.

In particular, it looks like specifying #pragma GCC optimize ("O3") at the top of your file is not actually equivalent to using -O3 on the command line. It turns out that the former doesn't result in std::min being inlined, and so the compiler actually does assume that it might modify global memory, such as your a,b arrays. This naturally inhibits vectorization.

A careful reading of the documentation for __attribute__((optimize)) makes it look like each of the functions main() and std::min() will be compiled as if with -O3. But that's not the same as compiling the two of them together with -O3, as only in the latter case would interprocedural optimizations like inlining be available.

Here is a very simple example on godbolt. With #pragma GCC optimize ("O3") the functions foo() and please_inline_me() are each optimized, but please_inline_me() does not get inlined. But with -O3 on the command line, it does.

A guess would be that the optimize attribute, and by extension #pragma GCC optimize, causes the compiler to treat the function as if its definition were in a separate source file which was being compiled with the specified option. And indeed, if std::min() and main() were defined in separate source files, you could compile each one with -O3 but you wouldn't get inlining.

Arguably the GCC manual should document this more explicitly, though I guess if it's only meant for debugging, it might be fair to assume it's intended for experts who would be familiar with the distinction.

If you really do compile your example with -O3 on the command line, you get identical (vectorized) assembly for both versions, or at least I did. (After fixing the backwards comparison: your ternary code is computing max instead of min.)

code is shown below

Try this

According to the way h3_rules is defined, then first you need to validate if the first index is an instance of a set, grab the first value of the set, and then just append the corresponding division.

I fixed this issue in Xcode by amending the runtime API checking.

Navigate to:

Product > Scheme > Edit Scheme > Run / Debug > Diagnostics

then deselect Main Thread Checker

To reduce the points to every fourth, you can use filter:

I would suggest visualizing your processed image to check if it is centred and have the right contrast. See: Visualize MNIST dataset using OpenCV or Matplotlib/Pyplot