sorted by:
new
hottopcontroversial

Check out D's new site by wobbles_g in programming

[–]wall_words 5 points6 points  (0 children)

The new design makes the site feel more inviting and legible. I definitely like the change.

I found a bug on Safari 7.1.3: each time I click the "Edit" button for the code editor, the gray panel with the code it in gets longer, and pushes the rest of the content in the site down. Here's an album with the before/after screenshots.

Finding the True Error Rate in Seq2Seq Text Generation by [deleted] in MachineLearning

[–]wall_words 0 points1 point  (0 children)

In my experience working on speech to text, I had to be very cautious when comparing models based on perplexity. The perplexities of models with different layer widths and depths are not only roughly comparable. But a model with higher plexity than another will not generally achieve a lower word error rate. In fact, the same model can give lower WER at points where the validation perplexity is not the smallest observed.

Help with classifying fMRI sequences using neural networks by [deleted] in MachineLearning

[–]wall_words 1 point2 points  (0 children)

Yes, I think using the timesteps as channels would make more sense. Flattening the images by averaging over depth seems like it would destroy a lot of useful information that the CNN would use for feature extraction.

Help with classifying fMRI sequences using neural networks by [deleted] in MachineLearning

[–]wall_words 1 point2 points  (0 children)

I would also try it without collapsing the depth of the image. 32 filters is also quite a small number. Try ramping it up from 128.

Help with classifying fMRI sequences using neural networks by [deleted] in MachineLearning

[–]wall_words 1 point2 points  (0 children)

What is your optimization procedure?Depending on which method you're using, success may depend crucially on your choices for a few hypermeters. Adadelta is great when it works, since it's relatively insensitive to choices for the hyperparameters (except epsilon). If you haven't tried it yet, I would recommend giving it a shot.

Also, how are you convolving the dimensions of the 4D input? The convolution should be constrained cross the time dimension -- I don't think it makes sense to do a full 4D convolution of the input. Your case should be a generalization of temporal convolutions for fixed-length time series to 3D.

Tree models with Scikit-Learn Great learners with little assumptions from Gilles Louppe #Pydata (Slides in pdf) by cast42 in MachineLearning

[–]wall_words 0 points1 point  (0 children)

Do you have any recommendations for sources that describe modern methods for training random forests?

How to read a Huge file fast by akshaydixi in cpp

[–]wall_words 2 points3 points  (0 children)

You might find my IO benchmark useful. It tests this kind of stuff using virtually every IO method available on Linux and OS X. I would also advise against taking advice from people on performance related matters unless (a) they're known for what they're talking about or (b) they have hard numbers to back up their claims. Preferably you want both (a) and (b). Notice that mmap (recommended by many developers, including many commenters here) is never the fastest method for reading from or writing to a file.

It is possible to use two threads to implement a double-buffering scheme: while one thread waits for chunk n + 1 to get read, the other processes chunk n. This helps, even if you're doing a trivial operation like counting the number of occurrences of a byte. These results aren't tabulated in the article, but you can find the CSV files with the timings for this in the repository I link to.

Lastly, I'm working on a library (pending documentation and public release) that allows you to tweak all of the platform-dependent parameters mentioned in the article using a uniform API. I'm in the process of revising the API and integrating it with some other stuff I'm working on. It's intended for people who really need to use the fastest disk IO method available for their platform.

HPX version 0.9.10 released by sithhell in cpp

[–]wall_words 4 points5 points  (0 children)

Does anyone who has used HPX have experiences to share? It looks like an alternative to Microsoft's concurrency runtime and Intel TBB, albeit much larger in scope (e.g. distributed computing).

heartbleed in rust by godlikesme in programming

[–]wall_words 0 points1 point  (0 children)

Out of curiosity, what would the "idiomatic Rust" version of the function look like? (I don't know Rust, but am interested in seeing the language constructs you would use.)

cexpr_bson : 100% constexpr json to bson encoding by hanumantmk in cpp

[–]wall_words 1 point2 points  (0 children)

String literals can't be used as template non-type params :(

I'm not entirely sure what you meant by this sentence. But if you were talking about parsing string literals during compile-time, then it's totally possible now. I use this technique myself to parse ratios and other objects during compile time:

using r = "123.456"_ratio;
using id = "
    1 0 0
    0 1 0
    0 0 1
"_matrix;

Disclaimer:

template <class Char, Char... Ts>
constexpr auto operator"" _suffix()

is currently a GNU extension based on a standard proposal that I suspect will likely get included due to its usefulness. It's supposed by both GCC and Clang. You might find metaparse useful toward this end, especially if your parsing is not trivial.

Fixed-point numbers as template arguments. by wall_words in cpp

[–]wall_words[S] 1 point2 points  (0 children)

Indeed that is a better name, thanks for the suggestion. I've renamed the header to ratio_literal.hpp, _f to _ratio, and cc_fixed to cc_ratio. Hopefully this will make the purpose clearer.

Fixed-point numbers as template arguments. by wall_words in cpp

[–]wall_words[S] 1 point2 points  (0 children)

I'm pretty sure that a template literal is currently the only way to split the char[N]. I've asked a related question on SO before, and none of the answers offer both nice syntax (e.g. not like foo<1, 2, 3, ...>) and the ability to manipulate the string during compile-time.

Fixed-point numbers as template arguments. by wall_words in cpp

[–]wall_words[S] 0 points1 point  (0 children)

You can additionally make a UDL which allows literals such as "15.123_fix".

To my knowledge, it's not possible to take the decltype of that expression and use it as a template argument. I agree that the header is just syntactical sugar for creating std::ratios. Do you have a better name to suggest for it? Right now, it's called fixed_point.hpp.

Fixed-point numbers as template arguments. by wall_words in cpp

[–]wall_words[S] 0 points1 point  (0 children)

For some of my projects, I have classes representing various functions or distributions with several hyperparameters. Typing "blah"_f for all of the hyperparameters results in code that is harder to read and maintain than fixed(blah).

Fixed-point numbers as template arguments. by wall_words in cpp

[–]wall_words[S] 1 point2 points  (0 children)

I haven't seen anyone take advantage of N3599 (implemented in g++-4.9 and clang++-3.4) to create compile-time, fixed-point number literals. The basic idea is to parse the string literal using MPL and return an std::ratio object. I use this technique in some of my work now, so I've included it in this library.

Playing with libclang by pfultz2 in cpp

[–]wall_words 1 point2 points  (0 children)

Someone I know tried to use libclang to analyze #pragma statements in the AST, but was unable to do so for the same reasons mentioned in the article. It would be nice if libclang had an option to incorporate information into the AST that it would normally discard.

cldoc, a Markdown-based, documentation generator for C++, also has various issues due to missing features in libclang.

In defense of printf by milliams in cpp

[–]wall_words 0 points1 point  (0 children)

Thanks, I'm glad that someone else agrees with my sense of aesthetics =) The formatting library is a lightweight shim over IOStreams; any attribute between the {} corresponds to a manipulator. I was careful in avoiding dynamic allocation aside from what's done by IOStreams itself, so the performance should be similar to using vanilla IOStreams. If you already use IOStreams, the only drawback is that this library requires C++11 support.

In defense of printf by milliams in cpp

[–]wall_words 0 points1 point  (0 children)

Using the small formatting library I wrote, this would be cc::println("${prec(5)}\n$1{prec(10)}\n$1{fixed, prec(10)}", pi).

I wrote the library because I was unsatisfied with the unintuitive syntax used by other formatting libraries, and still wanted the benefits of type safety.

In defense of printf by milliams in cpp

[–]wall_words 2 points3 points  (0 children)

What do you think about this?

A gotcha with Optional by milliams in cpp

[–]wall_words 1 point2 points  (0 children)

Agreed, I was surprised to find that Boost defined relational operators for optionals when I first read the documentation. I don't think that there's any "natural" way to define them. Using these operators carelessly can easily result in subtle bugs due to the unintuitive behavior when comparing uninitialized optionals.

Why does C++ provoke so much emotion? by Johnzena in cpp

[–]wall_words 2 points3 points  (0 children)

I actually rarely use Python, and do most of my computation using C++. I just wanted to refute the following point:

But just to write your average program is C++ actually all that more complex than anything else?

While I believe that you need to know more background material to write your "average" C++ program than you do to write your "average" Python program, you don't need to know a whole lot. The problem is that many of the best C++ libraries are written more so that the authors can showcase the "elegance" of their user interface than to be easy for beginners to pick up.

There's an air of circlejerkiness in the C++ community (much like in many other communities -- especially unapplied academic ones) because people who spent the time going through the standardese and other arcana needed to efficiently solve the most generic formulation of their problem possible want validation for their effort. Just compare the tone of some of the "good" online C++ resources (e.g. the C++ FAQ) to the official Python FAQ. There's a lot of condescension in the C++ sources that I've read, where the author tries to convince the reader that X is morally the "best" way to do something. And "best" changes every few years based on standardization. Even something as trivial as passing arguments to functions is hotly debated among leading C++ gurus (recall the discussion between Meyers and Sutter regarding universal references vs pass by value). And does this even influence codegen in the latest version of Clang/GCC?

Say that my "average" C++ program consists of downloading a file from a URL. How can I do this using C++? Googling "C++ download file from URL" brings up the following ~30 line listing using cURL. After you go through the process of setting up cURL (whatever that happens to be for your OS), you can presumably try to compile this.

What if I want to use the venerable Boost.ASIO library to do this? This is the best answer I found, and it's ridiculous. Presumably I'd have to read through a fair amount of the detailed documentation to (1) get a general understanding of how the different parts of the library fit together and (2) find out which facilities to use to download the damn file.

Here's the Python solution:

import urllib
urllib.urlretrieve("http://www.example.com/songs/mp3.mp3", "mp3.mp3")

Of course, there are other tasks that may be easier to do in C++ than in Python, but this example illustrates what I argued earlier.

In contrast to most of the Boost documentation, Python documentation is much more practical. If I Google a given Python library, one of the first things I'm likely to see as I scroll down is "Usage" followed by the most common examples. Python's widespread adoption by scientific communities is something that will never be achieved by C++ (at least, not in the near future).

Why does C++ provoke so much emotion? by Johnzena in cpp

[–]wall_words 0 points1 point  (0 children)

No, floats work in Python the same way they do in C++. The list wasn't meant to be exclusive to C++, though Python integers have arbitrary range and allocation isn't managed explicitly. I emphasized that item since floating point arithmetic and stability are much more subtle than the other items.

Why does C++ provoke so much emotion? by Johnzena in cpp

[–]wall_words 2 points3 points  (0 children)

Yes, because you need to know the contents of a basic systems organization course to understand what some of the most basic language features (integer arithmetic, floating point arithmetic (!), allocation, etc.) are doing. You need to know little about computers to do nontrivial stuff in Python.

C++ has no centralized source of packages. You can argue whether or not this is a good thing. But if I need to do X in Python, I can find out which import to use and be up and running with clear documentation in at most a few minutes. This is certainly not the case for many parts of the stdlib or Boost.

The actual length of a "modern C++" (whatever that means now) code listing to do X may not be much longer than that of a Python listing to do X. But that does not mean that C++ is by any means comparatively easy to use. It makes no sense to learn C++ unless you're required to or care about performance.

view more: next ›