From 7/24/2019, 8:53:15 PM till now, @andersource has achieved 637 Karma Points with the contribution count of 148.
Recent @andersource Activity
Not a rare algorithm, but used Dijkstra along with [0] to create a timelapse video from a sequence of videos. The Dijkstra was used to choose paths of most similar frames across videos to morph between.
[0] https://learnopencv.com/face-morph-using-opencv-cpp-python/
The dangerous playgrounds of 1900s through vintage photographs
191 points • 173 comments
Dollar Auction
1 points • 0 comments
Britain pulls the plug on its UFO hotline (2009)
2 points • 0 comments
From TFA it appears this is not practical yet, maybe in the future:
> For now, it’s primarily a theoretical advance, since the speed improvements kick in only for networks that are far larger than the ones we encounter in the real world, for which maximum flow problems can already be solved fairly quickly (at least, if they don’t involve minimizing costs). But pieces of the new algorithm might see practical use within a year, predicted Richard Peng of the University of Waterloo in Canada, one of the algorithm’s six creators. And in the coming years, researchers said, computer scientists will likely find ways to make it more practical and perhaps even slightly faster.
Interactive data exploration utilities with dimensionality reduction and D3.js
3 points • 0 comments
Interactive data exploration utilities with dimensionality reduction and D3.js
1 points • 0 comments
That's cool, I didn't know that, thanks!
Thanks for your reply!
I've only seen (and used) this for linear / convex models and constraints, so that's actually linear / convex programming (highly recommend the cvxpy library [0]). I was curious if you've integrated that into DL models.
Here's a fun example I did for a uni project: say you have a small recipe dataset, where for each recipe you have the ingredient list ("3 tbsp sugar", ".5 kg flour" etc.) and macronutrients (carbs, proteins, fat), and you want to learn to predict the nutritional content given a list of ingredients.
With a bit of text manipulation you can split each ingredient text to "amount", "measurement unit" and "ingredient type". Then you can decompose the nutritional values into nutritional density of ingredients and the conversion of measurement unit -> actual mass for each ingredient type. Then you can introduce constraints in the form of known conversions between units, e.g. 1 cup = 16 x tbsp, known nutritional densities of some simple ingredients, and known unit conversions for specific ingredients.
It worked better than simple regression (that didn't take into account unit conversions) and a simple MLP, though not sure how it would compare if you actually tried to finetune a language model to the task. The overall predictions weren't too accurate, but for common ingredients it actually gave very close nutritional density values (without being constrained), which was cool.
Edit: another constraint I initially forgot about is that each gram of an ingredient cannot contain more than a gram of macronutrients (it can contain less because water), and of course nonnegative nutritional density.
Makes sense, and designing proper constraints is an art on its own.
Out of curiosity, did you apply the constraint as a term in the loss or did you use constrained optimization?
I fully agree with your perspective, and I think there's a lot of cargo-culting in that area that explains your observations. Sure, if you're a FAANG collecting massive amounts of data comes almost for free, and it makes sense to find a way to properly utilize that data. But for many startups collecting that amount of data doesn't make sense (either because they don't have a lot of users yet or because their domain isn't high-freq digital activity or both), and in those cases it can be more worthwhile figuring out what to do with the little data they have than shoe-horning their way into Big Data (TM).
There's much more money to be had convincing startups to use big data infrastructure and train huge nets on GPU clusters etc. than convincing them to iterate on small ad-hoc models developed in-house. Not saying that big data or models are necessarily wrong for small startups, just that they don't have to be the default.
This article strongly resonates with me (thanks OP!). Models trained on huge datasets are truly very impressive, and it's easy to jump on the hype train of "BIG MODEL GO VROOM" and overlook the cool / useful things one can do with a little data and solid domain knowledge.
Transfer learning can be immensely useful when applicable, but many times it's not (e.g. imagine a medical domain where you track a patient through some process, recording procedure choices, measurements and outcomes, etc., where it can be difficult to find relevant data elsewhere).
Some approaches I've found useful:
* Get to know the domain really well
* It's not a lot of data - that's a potential for rich interactive visualizations that allow you to get to know the data quite well, and grok how it relates to the domain knowledge
* Following the advice that ML models in production could/should start with simple heuristics, view your model more as an augmented heuristic than a powerful model to solve everything - that means also figuring out how to catch and handle cases where it's wrong (which is something one ought to do anyway)
* Invest in tailoring priors suitable to the problem, based on your domain knowledge and understanding of the data. This can range from writing your own loss function to training an ad-hoc type of model, not based on DL, e.g. using metaheuristics (genetic algorithms, simulated annealing etc.). The advantage of small data is that evaluation on it can be relatively fast and ad-hoc models using nonstandard techniques can be realistically optimized (sometimes, depending on context of course).
SEEKING WORK | Remote | Data Science
Need to solve a nonstandard optimization problem? Could use an interactive visualization to explore complex data? I'd love to hear about it!
hi@<username>.dev
Lasers in Space: remote-friendly physical co-op game made in 24h for a hackathon
2 points • 0 comments
In case you're asking about the parent comment (s/Differential/Differentiable), it means the title should be "differentiable CV" (instead of "differential CV").
"Differentiable" describes some computation for which derivatives can be computed. "Differential" is a more general term which means that something has to do with differences, e.g. differential equations deal with equations that specify how things change together.
With the recent surge in deep learning came significant improvements in optimization techniques and hardware, making it feasible to formulate some computations in a differentiable manner. Doing that allows one to optimize the computation process relatively efficiently, at least in theory. Some other examples: differentiable programming[0] (other differentiable techniques are a subset of this), differentiable rendering[1], differentiable signal processing[2].
[0] https://en.wikipedia.org/wiki/Differentiable_programming
How to determine which of two sequences of coin flips is real and which is fake?
1 points • 0 comments
Overall agree, although regarding
> large enough AI models cannot be "race-blind" because if you remove race as a feature, they will be able to infer it anyways from proxy features
In theory using a gradient reversal layer and an adversarial classifier you could do just that, to an extent. It could hurt the model's performance, which is exactly your point (should we ignore features with signal because they can be used to discriminate.)
> I'm kind of looking for a unified data storage with visualization options.
That phrase reminded me of elasticsearch & kibana[0], though that may be an overkill (the elastic stack is a lot of work).
Also seems like datadog has a solution in the space[1], haven't used it though.
I agree in principle, although I think to get an effect size similar to what DK observed you'd need quite large noise. Which again comes back to the test reliability.
Right. Just to be clear, "an effect like this" is (comparatively) unreliable tests, not some elusive statistical phenomena as implied by the original article. I'd have no issue if the author had called the article "the DK effect is due to poor skill tests", spent 5 minutes showing that the DK results are consistent not only with their claims but also with unreliable tests (like you did), then went on to show data that indicates that the tests indeed are not reliable enough to draw the conclusions that DK did. Instead the author spends a lot of time digging under the wrong tree and no time at all saying anything about the reliability of the tests.
site design / logo © 2022 Box Piper