778 karma · joined January 23, 2011
Current: Staff Robotics Engineer at Chewy
Prior: Atlas @ Boston Dynamic; Robotics and Embedded Systems Engineering @ Amazon Robotics, Rethink Robotics, iRobot; Automation Engineering @ Ginkgo Bioworks.
Early Career: Electrical Engineer in Semiconductor Industry @ Applied Materials, Analog Devices, Allegro Microsystems
We might be more on the same page than I realized On the one hand, I agree that it doesn't imply that it is necessary to have access to more than one sense.
On the other hand I do think that having access to more senses may make the problem a LOT easier, especially during the training process for teaching systems to do things like try to distinguish objects by sight.
Don't get me wrong, the progress made so far has been incredible, but it isn't surprising that we are eventually running into limits given the limited amount of data these systems have to train on.
Sort of riffing off of this - In particular, my sense is that when you are training on 2-D pixel data only, it is no wonder that no matter how clever your network is to extract high-level features from the data, you are going to run into these kind of issues. We are asking the system to perform a task (describing, classifying, etc.) about a fundamentally 3-d world, using only a 2-d image, when it has never had a "concept" of the world in 3 dimensions. I think that we take for granted that when we are learning, not only do we get information by seeing, but also touching and manipulating objects and existing in the world around us. We can see things in different lighting conditions, and we can also move our heads and our bodies and around the world and see things from new angles and manipulate them to learn the rich set of correlations between what we see, and what we experience...basically the rich structure of the world around us. A system which is trained on images alone doesn't have the integrated knowledge, which is what I was hoping to get at with the anecdote of adults being cured of blindness.
When you look at some of the work we do to augment visual data sets, by scaling images, cropping them, rotating them, skewing them, etc. its basically a poor mimcry of something that humans and animals get just by being in the world...this idea of learning that things remain the same and have a certain structure, regardless of the viewpoint we see them from. (From what I understand, this idea is also part of what inspires capsule networks).
Anyways, to come to my main point. Yes, you can absolutely identify objects, even a completely novel object after only seeing it once or twice. But I would argue that this is only because you already have a rich framework of the world as 3-dimensional spatially, along with all of the other priperties that object have that you have learned. So when you see a 2-dimensional picture, your brain can form a 3-d image of the scene, identify materials of objects, etc., which you can leverage. Things that our current AI systems have no idea of... so perhaps its a miracle they made it this far, and no wonder that we find they can get fooled by flipping pixels!
(I'll end my rant here with the caveat that I am a roboticist, so perhaps I have very skewed views of intelligence and feelings about embodied intelligence, but I'm willing to learn and be disabused of my notions!)
Yes, you can make the software deployment go easier, and resin looks like an interesting project from that front. But that really is only a small part of the problen, and those hardware problems you described aren't trivial. The testing you described to convincingly show that your device can handle the environmental requirements isn't trivial. (And by environmental, I dont just mean weather, but also things like available power quality, vibration, etc.)
These industrial devices aren't expensive just because the suppliers aren't aware of RasPi, or are looking to gouge you. Its because they put in a lot of work to qualify these devices for their intended conditions. The RasPi, hacked up solution might actually be the WAY more expensive option over it's lifetime, if I have to roll maintenance crews every couple of months to replace SD cards or fix a flaky connector. And god forbid our code hangs in a way that makes all of the lights at an intersection green. "Oh you have a way to prevent that? Prove it." Designed to fail works fine for microservices where I can spin up a new instance rapidly, but it isn't the best match for industrial or infrastructure in most cases.
Apologies if I'm coming across overly snarky here. I genuinely love the RaspPi, and its got a great niche for prototyping, hacking up one-off projects, or even as the base for many types of connected projects. But I've also worked on industrial and infrastructure types of systems, and more than once I've seen someone say that they've got a cheaper solution to X, when really they've got something that may look cheaper if your only looking at upfront costs, but they are completely ignoring the lifetime costs of the solution.
(Also, is there a model Y in the works?)
https://en.wikipedia.org/wiki/Vickrey%E2%80%93Clarke%E2%80%9...
Not a mathematician so I don't have any great references, but a couple bits in the press about it:
http://blogs.cornell.edu/info2040/2015/10/20/application-of-...
https://www.wired.com/2015/09/facebook-doesnt-make-much-mone...
Even without perfect timing of the market, it's a pretty easy decision for a portfolio manager to look at this and say: "While, like any other asset, past performance isn't an indicator of future performance, given the price history and increasing trading volume over time, the risk/reward balance skews heavily in favor of putting at least some tiny bit of money into crypto for all but the most risk-averse."
That said, while I don't think the exchanges need to (or realistically could) coordinate on circuit breakers, I do think it's entirely reasonable for there to explore this type of mechanism on a per-exchange basis in the case of GDAX and other exchanges where margin is allowed, to prevent the whole "cascading margin call" thing that happened with ETH to happen again. That could take a lot of forms, including limiting the size of market orders to not eat 30% of the book, or not allowing 1 market order to trigger margin calls if (insert criteria here)
(That said, they could also just say "that's how margin and trading goes on low-volume, highly volatile assets" and technically be correct, but much like their decision to reimburse some traders, this is more of a business decision and wanting to keep your customers. Not sure what the "right" answer is.)
In the situation with ETH, a bunch of automated margin calls happened because of one large order on the books, dumping the price down to 10 cents! GDAX/Coinbase repaid a lot of people who lost money then, even though they didnt have to. They may now have some dumb heuristics that slow down trades / whatever if a bunch of large orders are going through, or price delta over a short time period goes too high. I remember looking at the charts today on GDAX and the 5 minute candle went from 20k open to 16k close before trading halted! I also heard from others that there were a lot of ~19k sells of 100 coins each on the books and executing.
So yeah, just speculating that this may bave been the case of someones boss at GDAX/Coinbase telling engineering "please don't make us do that again", after they ate the cost last time! :-)
From the exhanges POV this is useful because more orders = more money for then.
From the market traders POV (the taker) this is useful because a lower spread and more volume means there is less chance of buying something they can't later sell.
For the market maker, they make their money on volatility (aka the movement if the price). If they think the price is going up, they will offer to buy at a price higher than the current highest buy offer. This reduces the spread and increases the odds of someone taking their offer. They will then later sell those coins, and make a small profit on the movement.
If they think the price is going down, they will place a sell order cheaper than the lowest sell, and then buy back later, making small profit whole keeping the same amount of coin / stock / whatever.
Basically a "market-making" trader is less in it for long-term, and more interested in making money on the movement.
Aside: You may have also heard of "short selling". This is when a market maker is betting the price is going to go down, but doesn't have anything to sell. In a short sale, they will borrow the stock/coin from someone else (such as the exhange or their broker), and sell it, promising to buy it back later to repay the loan of said stock / coin. Easy way to bet on perfornance of an asset you don't owb, but dangerous since if you are wrong and price goes up, the person who loaned it to you will want you to repay it back sooner rather than later, costing you money!
So to give you a little more info: 1) Yes, there are big players (aka "whales"), and the rest of the "small fish", all playing in the same pond. The interesting thing about cryptos is that the are more "money-like" than "stock-like" when it comes to trading. Meaning just like money, where I can buy a fraction of a $, I can also buy a fraction of a bitcoin. So there are a lot of smaller players who will buy, say .01 BTC for $150 right now.
But while there is a general consensus that bitcoin is $15k by virtue of people paying that much for it, the "whales" (people with a lot of money or coins), can cause issues because they can put a lot of volume on or take a lot of volume off the order book at once. This happened to Ether this year, dumping the price for a few minutes from >$300 down to about 10 cents for a few minutes! https://blog.gdax.com/eth-usd-trading-update-5d8142b5bdc1
In fact, there is some speculation that a lot of the rise right now is from Wall St. / big firms buying up a lot of coin, as futures trading on Bitcoin is coming in the coming weeks! (But I don't know enough to comment on that theory)
As far as preventing exchanges themselves from colluding... it would be difficult but not impossible, because again the price on the exchanges comes from the traders, not the exchanges themselves. (Theoretically it is possible that an exchange could do a bunch of "wash trading" / make up a bunch of fake trade volume to make demand look higher than it was, but given that there are a number of exchanges in a number of different countries, coordination there might be difficult)
- "Market Maker" - By placing an entry in the order book, which says something like: "I have up to 100 Bitcoin I'm willing to sell at $15,000.01 a piece", or "I'm willing to buy up to 100 bitcoin at 14,999.99 a piece".
- "Market Taker" - You can do this by looking at the book and saying: "I will take that deal". You can also do a "market order", saying: "I want to buy 100 BTC at market price", in which case, the exchange will match you with as many sellers as it takes to fulfill your order of 100 BTC, working from the lowest offered price on up.
The price is determined by either whatever the last trade executed at, or a weighted average of the buy side and sell side of the order book. If you hear someone talking about the spread, that is the difference between the highest buy price offered on the book, and the lowest sell price offered on the book. (2 cents in my above fictitious example).
The exchanges make their money by running the order book, matching makers and takers, and charging a small fee for the transaction. (On GDAX for example, market makers get charged no fee, market takers get charged some fraction of a %). The exchanges make money on the volume of trades going through them.
It can get a bit more complicated, but I hope that gives you an idea!
I'm addressing this as someone who has done C++ work on very small embedded systems (e.g. microcontrollers with no external memory) including RTOS code and low-latency control loops, and there were definitely some nice features in C++ that can save you some time and lines of code without adding a bunch of needless overhead. Of course, there was a learning curve when bringing new people on board the project about what was/wasn't allowed for performance reasons. In general though, I see no reason why there couldn't be some subset of C++ used for kernel development other than Linus' / the kernel dev community's general distaste for it.
I can see the argument from Linus' POV about avoiding over abstraction, and knowing exactly what your code is doing on a low-level, but at the same time it leads to a lot of reinventing the wheel and makes me think there is a better balance to be found.
Also: "For most modern browsers (including Firefox 38+, Google Chrome 34+, IE 11+) setting the autocomplete attribute will not prevent a browser's password manager from asking the user if they want to store login fields (username and password), if the user permits the storage the browser will autofill the login the next time the user visits the page. See The autocomplete attribute and login fields."
(From: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Fo...)
Coming from an embedded background, the form "while (true) { // do nothing of interest }" is seen a lot in embedded code. If your code is interrupt driven, or running certain RTOSes, you would usually see this at the end of main(), since everything happens in interrupts. You might also see this in error handlers, and "unimplemented" interrupt handlers during development, as a way to trap the program without halting / resetting the system completely. If this kind of loop was optimized out / you returned-from-main on your embedded system, interesting and unintended things may happen.
While I've never had problems with these particular loops being optimized out (that I can remember!), I do remember having to do other vary silly hacks to try and tell the compiler not to optimize things out, because something is happening in hardware that it wasn't aware of, so I wonder if this is just a practical way of making sure that this kind of code keeps working with newer compilers, even in the face of aggressive optimization.