clickok

"Regular" paper is usually 20 lb. or 24 lb.; I am not sure what that is in gsm. So far I've found it to be too thin, actually, though I'm using an inkjet printer (modified for a continuous ink system).

I've used 28 lb. and 32 lb. paper, although next time I see it I'm going to buy something thicker (36 lb. or 40 lb., assuming the pattern for commercially available thicknesses holds inductively). Thinner paper seems to be a bit too transparent, but that might be a function of the type of paper or my printer's generosity with regards to ink.

Having sewn and bound a couple of books following similar tutorials, my advice is to actually get a professional print shop to make your books if you want something of professional quality[0]. Doing it by hand is a viable hobby, but even with my continuous ink system, it's probably not economical because of the time required to bind everything together. Printing with laser is probably more expensive.

-----

0. If you just want to get some notes together in a reasonably permanent form, here's my three step approach to creating usable, but necessarily "beautiful" books. First, print off your book, arrange the pages, and add a blank page before the first page and after the last page. Second, align the pages carefully, ensuring that the spine is flat. Clamp the pages together, using something flat (another book, or a piece of wood works) to distribute the pressure. Finally, apply some Gorilla Glue (or similar) to the spine of the book, ensuring that the entire spine is covered but wiping away excess insofar as that is possible. Leave overnight, or until the glue cures.

The result: a surprisingly durable book from a process that takes less than 10 minutes, assuming you've got the materials handy. You can make it more presentable by adding a cover (I cut folders or cardstock into a book cover, and then glue them onto those blank pages).

It's another way of saying that T - λI is not a one-to-one map, meaning that (T - λI) is non-invertible. So there are vectors x and y such that (T - λI)x = (T - λI)y for y ≠ x.

Which means that (T - λI)(x - y) = 0, and in general because of linearity every scalar multiple of (x - y) also maps to zero. Letting (x - y) = v, we could get (T - λI)v = 0 ==> Tv = λv, which is perhaps a more familiar definition.

So, it's a neat way of expressing the concept, but I'm not sure what it buys you in terms of improving one's intuition.

Neat!. I am working on artificial muscle as a side project[0], especially the kind you can (cheaply) 3d-print. Earlier work used these sorts of soft actuators similar to regular muscle-- you make a bunch of actuators that move in a particular direction, strap them to a skeleton, and then activate them in various combinations to move the skeleton.

3D printing, on the other hand, allows you to build more complex actuators (that don't necessarily apply force in a line). Origami-inspired designs (particularly rigid origami[1]) are related, in that you can design a particular folding pattern and have it fold and unfold to exert force in a particular way.

I was originally inspired by the work on artificial muscles actuated by a phase change (liquid to gas, with attendant increase in pressure) from Columbia[2]. Some combination of the two techniques might be better than either alone, allowing for fast-twitch soft actuators to fill the roles that servos stepper motors have previously occupied. Plus, they're likely to be cheaper in general, customizable to specific tasks, and probably safer in situations where humans might get in the way of the robot's motion.

----------

0. Most of the time I am working on reinforcement learning theory, and so building an actuator with difficult-to-model dynamics seems strange. However there's a lot RL could offer here, either learning how to control those dynamics from scratch or refining an existing model.

1. Wikipedia and its related/external links have a good overview: https://en.wikipedia.org/wiki/Rigid_origami If you just want a cool example of What Rigid Origami Can Do For You, check out: https://en.wikipedia.org/wiki/Miura_fold

2. See the press release: http://engineering.columbia.edu/news/hod-lipson-lifelike-rob... and the associated paper: https://www.nature.com/articles/s41467-017-00685-3

It wasn't clear to me either, and I really dislike when papers expect the reader to 'notice' some rather non-trivial manipulations. So I wrote up my unpacking of the equivalence: http://rl.ai/posts/max-entropy-rl-explanation.html Please forgive the possibly screwy LaTeX, as I am in a battle with my static site generator.

If you're just wondering about the meaning of (18), it claims that for a given state, the entropy of the original policy plus its expected Q-value is less than the entropy + expected Q-value of the π-tilde policy. Where they are using Q_{soft}^{\pi} to denote the state-action values (with entropy term) for an arbitrary policy. In (17) they introduce a new policy, \tilde{\pi} defined through the Q_{soft} values for some policy π, with the probability of taking action 'a' in state 's' proportional to the exponentiated Q(s,a).

In standard policy gradient, the weights for (apparently) suboptimal actions are free to trend downwards to arbitrarily small values. If you're using a Gibbs distribution[0] the probability of executing alternative actions is nonzero but potentially very small.

With entropy methods, you add an artificial bonus towards policies that execute more varied actions[1]. So while there's a tendency towards improving the policy by executing apparently favorable actions, it is counter-balanced by a term incentivizing different choices.

Why not just optimize using standard gradient descent? Typically, the variance is high and the algorithms optimize very greedily, so you end up in situations where a few bad trajectories cause certain actions to be avoided. Or the agent might need to refine its policy for the states that come afterwards, but because that hasn't happened yet, the actions that lead to those states are ignored[2].

So exploration needs to be incentivized, and while this can be done with ε-greedy or optimistic initialization, those techniques are kinda ad hoc, while entropy methods have a bit more mathematical/philosophical heft behind them. Plus they seem to work, which is always nice.

-----

0. That is, if you'll excuse the notation: p(a) = e^α/Σ e^β where 'p(a)' is the probability of taking action 'a', with weight 'α' and you're summing over all possible actions (with weights denoted 'β') in the denominator.

1. For a discrete space (absent other information), the maximum entropy distribution is the uniform distribution, i.e., all actions are equally likely.

2. For example, a human-like robot might try stepping forward, but hasn't learned how to balance after it lifts its foot, so it stumbles and falls. Crawling is less efficient, but provides constant progress and is easier to learn. So the robot 'gets stuck' crawling since it had a bad experience walking and doesn't attempt it again.

It's something of a pattern for Google. Existing products (say, Theano and Torch) were revolutionary, but had a number of pain points that were difficult to remove[0]. TensorFlow is essentially Theano without those problems, and with the guarantee of continued relevance thanks to Google's backing[1]. And of course, they reap the benefits of making it "open-source" while keeping a closed version for private use, similar to Chrome and Google Ultron.

However, I still feel kinda nostalgic for those warm summer days, writing my first autoencoder in Theano and using it to make blurry versions of photos.

-----

0. Theano had some truly gnarly exception tracebacks, which made it difficult to identify if you'd made a truly incompatible model or if one of the layers/operations just needed a datatype specified.

1. I wish more companies did something like this. It's not necessarily innovation, so much as having a corps of people experienced with some wondrous but unwieldy technology and then giving those people the opportunity to reimplement it "right". Maybe there are many companies that attempt it, but instead produce a clone with problems of its own? Or maybe you need someone like Jeff Dean supervising the project to make sure everything comes together?

We tried that; the reason deep nets are popular is that they outperform geometric (or other problem-specific) models. This might be because they implicitly develop such representations somewhere along the way, or because such a representation is not really necessary for visual classification.

Additionally, introducing ancillary modules is not without cost-- you might gain robustness to some kinds of adversarial inputs at the expense of becoming vulnerable to others. There's plenty of ways to fool biological visual systems: c.f. magic-eye posters, optical illusions, or the various exploits described in Lettvin and Pitts' paper "What the Frog's Eye Tells the Frog's Brain".

I am unsure what you mean-- do you mean with different training sets but the same testing set?

It's an interesting question; maybe the reason for (some) of these adversarial vulnerabilities is due to a handful of bad training examples. You could formulate it as a search problem to see if there's particular images (or small groups of images) that are responsible for the adversarial vulnerabilities. This might then indicate that some of these perturbations are really just taking advantage of the fact that neural nets tend to "memorize" some of the data, so we're not really exploiting some deep structural feature so much as just feeding the echo of an input that the net has learned to automatically classify as, say, a computer/desk[0].

It would be a good project, but I don't have enough GPUs on hand to train scores of deep nets from scratch.

Assuming one were to bite the bullet, it might also be worth trying different data augmentation strategies. Most of the time, we try to eke out additional performance/robustness by using the same sets of transformations (translation, rotation, cropping, rescaling, etc.), but if the net is vulnerable to adversarial examples because of something in the training set, then you might just be making sure that adversarial vulnerability is present everywhere in the image and at multiple scales.

On a related note, there's an interesting paper about universal adversarial perturbations, i.e. those that can be added to any image and thereby induce a misclassification with high probability[1]. This effect holds even across different models, so the same perturbation can cause a misclassification in different architectures.

------

0. Neural nets learn by some combination of abstraction and memorization. If, for some reason, many members of a particular class are hard to generalize, then it's possible that they instead learn to identify some particular aspects of those classes (that are not usually present in other images) and have a disproportionate response when those features are present. If such features are not obvious to human visual inspection, then we get misclassifications without insight into why they were misclassified.

1. https://arxiv.org/pdf/1610.08401.pdf

There are many reasons to prefer simplicity, not just that prior to ubiquitous computing complicated models were intractable. Off the top of my head:

A simple model can be "robust" to errors because the errors tend to cancel out. More complex models are typically more sensitive to slight changes in the input (and therefore noise), so even if your model is exactly correct, small errors in the input can be amplified yielding large errors in the predictions.

Or it can be preferable because it tends to fail in certain characteristic ways. For example, Newtonian mechanics breaks down at both the high and low mass/energy scales, but it's usually possible to determine whether you'll have to employ GR or QM (and perhaps despair if both are required simultaneously).

Also, it's much easier to test simple models (and typically also to train them if we're talking ML)[0]. Furthermore, if your first approximation is well-understood, then you can complicate it to address new data.

Simplicity has many virtues; just because we can employ more complicated methods now doesn't mean that we should, or that the sole reason previous generations of scholars opted for simple models is because they couldn't perform the calculations needed by more complex ones. In general we can't expect to know the underlying truth with certainty, but maybe a question is so important and so well investigated that it merits a seriously convoluted answer. For less well-studied or relatively unimportant problems, a model that is obviously wrong but easy to use is usually preferable. It's called the bias-variance trade-off for a reason (although you should still try to get a good deal, which in this case means minimizing error or perhaps risk).

------

0. This point can be particularly subtle-- we generally have more computing power available than (quality) data. I can try millions of variations on a given hypothesis for a small data set relatively quickly and find a handful of results with publishable p-values. This is how you get replication crises. Even if one of my hypotheses is invalidated, I can generate many more that are still consistent with the data. Take string theory for example-- a naive approach to testing the various parameterizations/permutations of the basic idea would run out of time before the heat death of the universe, so absent theoretical work constraining the possibility space, it would be effectively unfalsifiable.

There's a lot details that need to be filled in to get a working algorithm from this idea, though. Like how to properly explore enough of the state space that you can estimate the ensuing entropy, and if it's possible to learn the utility and its variance in a sample-efficient manner using an RNN. It might be better to start off with an environment with unknown dynamics but an exact representation before going full nonlinear function approximation.

Nonetheless it's an interesting post; I like the idea of coming up with abstract "goals" that can be applied to any environment (without having to construct a reward function) that yield complex behavior. Even if it doesn't do precisely what you want it's useful for exploration and perhaps a good stepping stone towards the desired behavior.

On a related note, I believe you can learn to predict the entropy of a Markov process using reinforcement learning, so it might be possible to extend it towards control.

I wrote up the basic idea: http://rl.ai/posts/generalized-returns-entropy.html which argues that if you had some sort of state transition model you could construct a reward function from it, and then learning the value of a state is also the "expected entropy" starting from that state. The state transition model can itself be learned, so no simulator is required. The reason I say "I believe" is that this is the product of original research, that is, procrastinating on my thesis. So there's a risk that I've made an error somewhere or missed prior work.

Part of the solution, I think, is making implementations of existing techniques available (and of course, rewriting them in Rust). Deep learning is popular because it's so widely applicable that it justifies the effort of learning to use it: deep nets work with image processing and robot control, and it's kinda unusual to have the mostly the same bag of tricks such different tasks.

But a reliable way to improve your performance (or at least write a publishable paper) is to examine why a specific technique worked, rewrite it as a differentiable function or finite automaton, and then implement it as a component in a deep net. So it's a cause for concern, but also an opportunity for academic arbitrage. I think it will work out eventually, but I become uncertain when I meet machine learning "experts" who are only familiar with deep learning and unwilling to consider anything else.

I'm not sure what I'm supposed to be offended by; in any event I was not talking about color histograms, but instead using "some OpenCV filters to extract colors and textures" and testing a linear model first before reaching for the big guns.

Sure, it's different from human-like perception, if that's really what the deep net is learning to do. But the burden of confirming that it's learning "concepts" instead of, say, dedicating a million parameters to implementing Sobel filters or wavelet transformations, or something even more trivial like "if all my pixels are one color, I am probably near an obstacle" is not on me[0].

When I approach a deep learning problem, my default assumption is that the model is out to humiliate me by learning something entirely trivial, and so I go to great lengths to augment my dataset and validate the fact that I got some extra mileage out of spinning up the ol' GPU that wouldn't have been possible (or at least, not as easy) with simpler methods. Because if you can use something simple, why not do it[1]?

For robots, it's maybe a full page of code to try some quick image filters, flatten them, and implement SARSA or Q(λ). Our demo used Pavlovian control (basically, TD methods to estimate the likelihood of running into a wall, and turning if a collision seems too probable). You can run it on a Raspberry Pi in real time, no GPU required, including the robot it costs less than $300, and it doubles on sax. When I'm done with my current project I'd like to try it with a drone, because aerial demolition derbies sound like the next great spectator sport[3].

----

0 . There are techniques you can employ, for example: examining individual units or clusters of them for their response to different frames, deconvolution, and of course, messing with the inputs. But this is rarely done, because it takes time away from using the magic hammer of DNNs to nail yet another previously difficult problem. This is understandable, but it makes me wish I had the time to develop some tools for performing quick and easy trepanation on deep models so that examining the representation becomes as easy as the training part.

1. My colleague Marlos Machado has written a paper that seems relevant to this sorta thing: https://arxiv.org/abs/1512.01563 . By looking at what Deep Mind's Atari DQN was doing (or what it seems to be doing) and developing the analogous linear features, you can get performance that is almost as good with a model that ingests data many times faster. That is, their median score was better than or equivalent to Deep Mind's. When it comes to RL, if you can use linear methods it's a huge help-- you know you're going to converge[2], probably quite quickly.

2. Subject to technical conditions, e.g. you're dealing with a stationary ergodic MDP, Robbins-Munro stepsizes, the environment's oblivious, the algorithm's on-policy, no purchase necessary, see in store for details etc.

3. It might not be as good a representation, but maybe a faster reaction time is more important? And also because it could be that quadcopters are an entirely different kind of beast and really do need some of that old time deep learning religion, and I don't want to fall into the trap of thinking that the problem is simple when it's not. With these sorts of questions you either have to do the experiment yourself or pay a guy from Google to tell you what they've done (and then be prepared to litigate).

For the things they showed in the video, deep learning is probably overkill. The main thing is having a robot capable of surviving its initial failures, and then actually collecting the data.

I can't comment specifically on airborne drones, but at my lab we've demonstrated that a robot[0] with an extremely low resolution camera and a very simple model is capable of learning to avoid running into walls with about a minute or so of training data. We use reinforcement learning with linear function approximation[1], and even though the robot sees the world through a couple hundred pixels, it's sufficient to discover that walls have a certain color and that if too much of your vision is "wall" you should probably move in a different direction.

The advantage of deep learning is that your agent hopefully learns to generalize, and so isn't fooled by changes in brightness/color or room layout. If your task is simpler than that, you could just use some OpenCV filters to extract colors and textures and let the a simple linear model figure out which ones correspond to obstacles.

----

0. An iRobot Create, basically a Roomba without the vacuum.

1. Incidentally, that means that if you don't require deep reinforcement learning, you can get simple obstacle avoidance up and running with like 5000 data points.

I have a similar setup to grandparent (Z10PE-D16 WS), running four last-gen TitanX GPUs with an EVGA SuperNOVA P2 1600W PSU.

I was a little worried because this is the most power-hungry machine I've ever built, but so far I haven't had any issues. But I'm not going out of my way to start an electrical fire, either.

The motherboard in question is pretty deluxe, the only thing I'd complain about is the boot time.

Sick burn. However, about ten paragraphs in, and after mentioning Trump serveral times, the article states:

> There is no indication that the White House was aware of the summons, which was signed by a Florida-based supervisor who works in an office that investigates employee corruption, misconduct and mismanagement. The supervisor could not be reached for comment.

So while this supervisor might be serving as a catspaw of the administration (who can say at this point?), this article (and the related discussion) seems to be using it to stir up controversy about Trump, whose only known involvement at present is as one of the subjects `ALT_uscis` tweets about.

The concerning thing is that the headline frames it in the context of Trump, implying that the government is pursuing the information at the President's request.

However, about ten paragraphs in they mention:

> There is no indication that the White House was aware of the summons, which was signed by a Florida-based supervisor who works in an office that investigates employee corruption, misconduct and mismanagement. The supervisor could not be reached for comment."

So all we know at the moment is that some manager, somewhere in Florida, is looking into `ALT_uscis`. And yet, the article mentions Trump multiple times (including in the headline) before that, giving the impression that Trump is pursuing legal action that would seem to compromise freedom of speech. It's not unreasonable to infer that the journalists taking this angle on the story have an axe to grind.

Either way, I took a brief look at the `ALT_uscis` account and didn't see any tweets alluding to malfeasance or obstructive action in their official capacity, so I'm inclined to agree that this is government overreach.

Eight GTX 1080s on a board that apparently has eight 16x PCI slots. The 2620 v3[1] has a maximum of 40 PCI lanes, so the GPUs are likely running in an 8x configuration.

At what point do issues with PCI bandwidth start to limit hashing power? Would this rig be faster with four Pascal Titan X cards?

---

1. https://ark.intel.com/products/83352/Intel-Xeon-Processor-E5...

Here's a presentation from one of their researchers, Harm van Seijen[0], to give you an idea of what sort of work they do.

Applying reinforcement learning to dialogue systems seems incredibly difficult, but if Maluuba (or others) can get a handle on the problem it would not be unreasonable to expect another revolution in the vein of applying convolutional nets to vision.

0: https://www.youtube.com/watch?v=s-8WkKhHYqA

According to a talk by Max Tegmark[0] (and its associated paper[1]), neural nets (particularly LSTMs) might be inherently better at this sort of thing due to the way they model mutual information.

Markov models are best suited to situations where an observation k-steps in the past gives exponentially less information about the present[2] (decaying according to something like λ^k for 0 <= λ < 1). Intuitively, the amount of context imparted by a word or phrase decays somewhat more slowly. That is, if I know the previous five words, I can make a good prediction about the next one, and likely the next one, and slightly less likely the one after that, whereas in a Markovian setting my confidence in my predictions should decay much more quickly.

So in answer to the grandparent, such a thing should be reasonably straightforward to build if it doesn't exist already, and it may offer improvements over a similar model based on Markov chains.

---

0. https://www.youtube.com/watch?v=5MdSE-N0bxs

1. https://arxiv.org/abs/1606.06737

2. Why is this? Lin & Tegmark offer details in the paper, but it comes from the fact that the singular values of the transition matrix are all less than or equal to one (an aperiodic & ergodic transition matrix has only one singular value equal to one), and so the other singular vectors fall away exponentially quickly, with the exponent's base being their corresponding singular value.

At first the headline made me skeptical because I expected it to be one of those clickbait articles where someone deploys excessive firepower solving a trivial problem. However! It turns out that cucumber sorting is well-suited to deep learning: a) there is enough interest to generate a reasonably-sized data set, and b) It is one of those difficult "I'll know it when I see it" classification/evaluation problems.

However, as soon as they described the actual solution I felt somewhat let down.

1. Reducing the input to 80x80 images is likely unnecessary; it removes some of the most important features (number of thorns, blemishes) from contention. If the issue is computational cost (and therefore training time) you might consider using cloud GPUs. However, a network with multiple "towers" (like Google's Inception model) could conceivably allow for evaluating the sorts of aspects that require higher resolution relatively cheaply (one-or-two convolutional layers with pooling and then a fully connected layer) along one pathway, while a different tower (with more layers or more units per layer) processes the resized images.

2. If the network used was just a modification of the MNIST one, then it seems like it ignores the ordinal nature of the problem. If cucumber quality can be ordered, why not use a regression model instead (or maybe regression along multiple criteria, like straightness, bumpiness, thickness, etc.) instead of treating each class as if they were completely separate?

3. Why not release the dataset? I have GPUs, the necessary background, and a few hours to try out some models. I also have a heretofore unrecognized yen to use my models to generate images of the ideal Japanese cucumber, so I'd be willing to do it for free.

I have used Epoch[0] and Rickshaw[1] before for similar purposes, and have heard that Plotly works well too (especially if the process that is generating the data is Python-based). For simple line charts, maybe Smoothie[2]?

Currently, I am trying to make a dashboard for visualizing many different data sources with WebSockets and Chartjs but it's still not quite ideal-- there's a bit of lag, and sending too much data via JSON really slows things down. If anyone has solved that this problem I would appreciate it if they told me how they did it.

0. http://epochjs.github.io/epoch/

1. http://code.shutterstock.com/rickshaw/

2. http://smoothiecharts.org/

I really liked this. Understanding what the AI is doing is usually something that comes with experience and a bit of analysis, but a good visualization can act as a shortcut to intuition. And this one in particular was nicely designed.

I don't believe that's the case. The Atari results were achieved via Q-Learning with neural networks (DQN stands for Deep Q-Networks), both of which have been around for decades. The basic algorithm is something you can implement yourself fairly easily, but (as with most things involving neural nets) getting it to really perform takes a bit of expertise.

So, DeepMind's greatest asset is they employ some really excellent people and have a substantial head start in terms of actually implementing AIs and getting them to work.

I mean, I understand your perspective, but it's kinda bizarre. The line about gridlock making free trade deals impossible seems to be the standard response to every criticism of the incredibly secretive negotiation process, but it never gets followed to the logical conclusion.

What is the point of having a democracy if the very principle of "rule by the people" gets subverted every time it presents an inconvenience?

Perhaps having a democratic open process is worth missing out on one of these deals.

This series has a lot of good stuff. If you want to clear the hump between "someone who knows what neural networks are" and "someone who can use neural nets in practice", there are introductions to the basic theory and foundational ideas.

If you already use neural nets and want to get better with them, Hugo Larochelle and Adam Coates have worthwhile videos. Larochelle's lecture describes the various sorts of optimization techniques you can try out, while Coates' goes into how to analyze training efficiency in terms of the model you've chosen and the hardware you have available.

Finally, there's some really neat stuff that's perhaps a bit more "cutting edge"; I particularly enjoyed Goodfellow's talk about adversarial networks.

TensorFlow makes some things difficult in truly baffling ways. For example, the last time I checked there's no built-in way to get gradients w/r/t say a single weight, rather you get a gradient sum. So if you want to do anything with the Jacobian (e.g. contractive autoencoders) you are better off using Theano.

The paper itself: http://hi.cs.waseda.ac.jp/~esimo/publications/SimoSerraSIGGR...

Part of what makes this neat is that their architecture includes exclusively convolutional layers. Networks that just use such layers have some incredibly useful emergent properties[1] and are about as good as networks with more varied layers[2].

Here they use that to allow for a wide variety of input sizes, because without a fully-connected layer, there's no need to resize images as part of the preprocessing, or indeed at any point inside the network.

I am a bit skeptical about it being able to handle "any" input size however, because ultimately the convolutions are going to be applied to pixel values, and I can imagine some sadist blowing up a vector sketch to ludicrous dimensions, so that the majority of the filters would see either the uniform color of a line or blank paper. Even supposing that worked, it would be expensive w/r/t memory and computation. But I haven't checked that on my own[3], so I may be wrong, and even if I'm right it could be fixed rather easily by down-sampling or cropping.

All in all, awesome stuff! It's always nice when you see a project that augments the human in the loop rather than just outright replacing them.

-----

1. For example, you can get segmentation "for free" when training a classifier, c.f. Fully Convolutional Networks for Semantic Segmentation --http://cs.berkeley.edu/~jonlong/long_shelhamer_fcn.pdf

2. These guys show that you can implement something like pooling via adjusting the stride length, and that the networks in question are pretty much state-of-the-art (circa 2014). Striving for simplicity: The all convolutional net -- http://arxiv.org/pdf/1412.6806.pdf

3. My graphics cards are busy at the moment. I just built a computer, named it (Serene Doreen the Mean Green Deep Dreamin' Machine[4]), and now I'm already looking for more capacity.

4. I'm not completely sold on the name; another contender was "Kim Jong GPU". At some point I will probably have to train a net just to name my computers.

How do you motivate designers to "flesh out" the full wardrobe/back catalogue?

If the workflow for adding new clothing sets is as slick as the frontend, I can see how it'd be easy to keep things up to date, but it's something else entirely having to go back through multiple seasons trying to remember which items composed an ensemble.

And (not knowing much about the fashion/clothing business) is it reasonably easy to swap out some items for similar looking ones if the original is not available (or too expensive), or do you face a problem where sometimes they just stop manufacturing things and there's no good substitutes?

Nice-- a beautiful, responsive website. What does the underlying stack look like?

Now all that remains is to fill it with content, which may be somewhat difficult since contributing users would presumably have to be fairly knowledgable about fashion[1]. Perhaps there's an opportunity to employ machine learning here, or maybe some sort of listing that's available online (or upon request from the showrunners).

---

1. Which leads me to think there might be a market for crowdsourcing tasks to particular demographics-- in this case, underemployed experts on haute couture. Maybe "Artisanal Turk"? Or maybe "hipster.io"?

I suspect the project was created in preparation for the SIGBOVIK conference[1] or similar. It's sort of a satirical or mock conference; these guys have created a number of ingenious projects over the years[2], but this one might be their masterpiece. Certainly it's going to give my own entry[3] a run for its money.

---

1. http://sigbovik.org/

2. http://oneweirdkerneltrick.com

3. A sort of analog neural net using a biological substrate to perform communication and learning. Basically, I've trained some wild dogs I found in the alley behind my apartment for function approximation. Originally I had intended to use a pretty standard hill-climbing approach, but they kept wandering away when I ran out of treats. My new method arranges them in a series of layers for PAC (provably all canine) learning, with the gradients transmitted by bark-propagation. I've not figured out how to implement convolutional operations in this framework yet, so I might hold off on publishing anything this year.