fcn | Chainer Implementation of Fully Convolutional Networks. (Training code to reproduce the original res | Machine Learning library

This is GCC bug 47488, which has been resolved in GCC 9. Upgrade your compiler.

The function body is irrelevant. GCC simply couldn't deduce anything if the expression contained a string literal, so it gives up at decltype(*beg + "name"), which (like you correctly pointed out) should resolve simply to std::string when *beg is std::string&.

To sum up what was already explained in the comments and fill in some blanks:

When using standard C library functions to work with files (printf actually works with a file stdout), the data is first cached in memory, and only written to the actual file when some condition is met:

• The file is closed
• The file is fflushed.
• The memory buffer is full
• etc.

In case of stdout, this will happen when the \n character is printed or when your program exists and the file is closed.

However, in your first code snippet you try to dereference (use) a pointer all.
Since you did not write a return statement in your test function, it is impossible to predict what value will end up being stored in all.

So, your program most likely crashes unexpectedly, and thus the buffer never gets written to stdout.

You should never test incomplete functions!
At the very least, build up a skeleton code that makes the function legal, such as a dummy return statement.

Otherwise, you will encounter "undefined behavior", which is another way of saying your program will react in weird and unpredictable ways.

Function submitTransaction has only 1 line of code:

Based on talonmies's comment I was able to compile the code defining the __device__ function dpmpar in main.cu file.

Then I found this post https://forums.developer.nvidia.com/t/external-calls-to-device-functions/17737 where the guy answered that CUDA doesn't have a linker on the device side, so it's not possible to call a __device__ function from a different .cu file.

With this in mind, I copied only the files that I needed from the library and made some modifications, like changing __cminpack_attr__ to __device__ and I rewrote the header file too. So basically I made my own device library (thank's again to talonmies's).

The last thing I did was move all this new files to the same folder where my main.cu and my makefile lives and I rewrote the makefile.

Now the code compile fine!!

On fcn() you get signal_collector * param_signal, but on the second line you say int *pointer = param_signal;. So you cast signal_collector to int, and then you send pointer which is of type int * to ManipulateMessage(), which expect signal_structure * as an argument.

Do you see the problem? In order to resolve this issue, change the second line in fcn() to:

TLDR; You want to look at Deconv networks (Convolution transpose) that help regenerate an image using convolution operations. You want to build an encoder-decoder convolution architecture that compresses an image to a latent representation using convolutions and then decodes an image from this compressed representation. For image segmentation, a popular architecture is U-net.

NOTE: I cant answer for pytorch, so I will he sharing the Tensorflow equivalent. Please feel to ignore the code, but since you are looking for the concept, I can help you with what you need to solve this.

You are trying to generate an image as the output of the network.

A series convolution operation help to Downsample an image. Since you need an output 2D matrix (gray scale image), you want to Upsample as well. Such a network is called a Deconv network.

The first series of layers convolve over the input, 'flattening' them into a vector of channels. The next set of layers use 2D Conv Transpose or Deconv operations to change the channels back into a 2D matrix (Gray scale image)

Refer to this image for reference -

Here is a sample code that shows you how you can take a (10,3,1) image to a (12,10,1) image using a deconv net.

You can find the conv2dtranspose layer implementation in pytorch here.

Since there are so many bars in one graph, I would use sns.catplot to draw the the different categories into a Facet Grid and then it would be much better for adding labels, which you can do with the custom function add_labels (please note the different parameters -- feel free to remove some/add others. I have adapted from this solution).

You could also make the x-axis more variable if you pass sharex=False when creating the catplots (see end of this solution)

Also, sns.catplot doesn't work well with adding to subplots, so that you can save as one figure. This is why I use plt.close(fig) to get rid of the blank figure we created, and this would also mean adding any formatting (such as adding a title) to that figure would be pointless, since we are getting rid of the figure at the end; however, there are hacks. One is to save as separate figures and use a solution from here: to combine into one .pdf. I think it would be better to have the extra space of one graph per page or image. Another option is to use somewhat of a hack to get into one figure:

You can use an "anonymous function" to do part of this. An anonymous function lets you adapt the prototype of the function, "binding" in values, so one piece of the puzzle is to do this: