vomjom

market cap = book value + discounted future cash flows = share price * number of outstanding shares

When you do a buyback, the book value drops (company loses cash), but the discounted future cash flows remains unchanged. The number of outstanding shares also drops.

The net result is the stock price increases as a company accumulates cash and uses it for buybacks because the number of outstanding shares drops.

Another way of thinking about it is that it's the same as dividends, but the dividend only goes to the sellers of the stock during a buyback.

There's nothing about PPO that helps it learn long-range strategies. It primarily lets you make multiple steps for a single batch so you can converge faster.

In fact, for a single step with no policy lag, it's equivalent to a standard policy gradient update.

DeepMind was also able to train a CTF agent with human-level reaction time: https://deepmind.com/blog/capture-the-flag/

I suspect the difference that allows you to train with reaction time is an RNN or compensating for the lag some other way. I'm testing that out right now with my own SSBM bot: https://www.twitch.tv/vomjom

The author of that paper has since built an agent that has human-level reaction time and is comparable against professional players: http://youtube.com/vladfi1

People rarely train ML models on macOS for the reason you mentioned. Most machine learning work happens on Linux, so this should work well there.

TensorFlow supports a standalone server mode where it receives computation graphs and executes them. This is nice because then you can remotely execute on any accelerator (Cloud TPU, multi-worker multi-GPU) from your laptop.

In their demo, they did exactly that with a Cloud TPU: it connected to a TensorFlow server that executed the machine learning training part of the program.

The talk is here: https://www.youtube.com/watch?v=gplTc2F5Wvk&feature=youtu.be...

Also see Chris's introductory post for the project: https://groups.google.com/a/tensorflow.org/forum/#!topic/swi...

Keep in mind that what you linked refers to TPUv1, which is built for quantized 8-bit inference. The TPUv2, which was announced in this blog post, is for general purpose training and uses 32-bit weights, activations, and gradients.

It will have very different performance characteristics.

An exponent bit flip, especially at later layers, would completely break inference.

Yeah, essentially a lot of supporting libraries were written in Python at first, and they need to be ported to C++ to make other languages train.

I'll discuss this a bit during my talk at the dev summit.

The short answer is no.

The long answer is yes, but only if you create the model in Python, export it, and then feed training data in other languages. There are some people doing exactly that.

Long term, I'd like to give all languages equal footing, but there's quite a bit of work left.

(I agree that thread-per-request works just fine in the majority of cases, but it's still worthwhile to write about the cases where it doesn't work.)

Responding to your original post: you argue that async/await intends to solve the problem of data races. That's not why people use it, nor does it tackle that problem at all (you still need locks around shared data).

It only tries to solve the issue of highly-concurrent servers, where requests are bound by some resource that a request-handling threads have to wait for the result of (typically I/O).

Coroutines/fibers are not an alternative to async servers, because they need primitives that are either baked into the language or the OS itself to work well.

It's not clear what you're suggesting as an alternative. My understanding is that you're suggesting thread-per-request, which has many known flaws. There are three approaches to serving requests:

1. Thread-per-request. This is a simple model. You have a fixed-size thread pool of size N, and once you hit that limit, you can't serve anymore requests. Thread-per-request has several sources of overhead, which is why people recommend against it: thread limits, per-thread stack memory usage, and context switching.

2. Coroutine style handling with cooperative scheduling at synchronization points (locks, I/O). This is how Go handles requests.

3. Asynchronous request handling. You still have a fixed-size thread pool handling requests, but you no longer limit the number of simultaneous requests with the size of that thread pool. There are several different styles of async request handling: callbacks, async/await, and futures.

#2 and #3 are more common these days because they don't suffer from the many drawbacks of the thread-per-request model, although both suffer from some understandability issues.

I think this is fair. Bandwidth costs money, usage likely follows a power law distribution, and their fees are reasonable:

AT&T: $10/50 GB = 20 cents/GB

Amazon S3/EC2: 10 cents/GB

It's not like we're being gouged here...

That would never happen.

The problem is that Amazon has no operations in certain states to avoid charging sales tax. Buying Borders would put them in every state.

The paper: http://research.google.com/archive/sawzall.html

On a related topic about another Google project: http://sergey.melnix.com/pub/melnik_VLDB10.pdf

At least in economic theory, a company does not give out dividends if it believes that it can get a better return on its cash (in terms of profit) than the investor can in the overall market.

But, companies must eventually give out dividends. There's a certain point at which the company's cash hoard gets so large that investors become unhappy (see Microsoft).

The article doesn't make it very clear, but Shiller's number is based on the average inflation-adjusted earnings of the previous 10 years.

See the Excel file here: http://www.econ.yale.edu/~shiller/data.htm

The stock market is still very highly priced compared to historical standards (excluding the past 15 or so years).

See also the graphs on: http://en.wikipedia.org/wiki/Robert_Shiller

It's possible to extract the address ranges, street names, city, and state using the TIGER/Line dataset. It won't give precise addresses (for example, if the range is 200-300 and address 250 doesn't exist, it won't say that). It also isn't that easy to deal with.

http://www.census.gov/geo/www/tiger/

I'll link to your TrueSkill post for those who haven't read it (it's excellent): http://www.moserware.com/2010/03/computing-your-skill.html

Although I already knew and understood TrueSkill before your post, it helped solidify my understanding. I hope you write more articles like that in the future :)

There are many obvious problems with this argument:

1. The 80% number seems to be pulled out of the air. It could be a counting error or a statistical aberration of that class, and the real Harvard number could revert to the mean.

2. The type of parents who could send a child to Harvard is a biased sample of the general population. It will mostly tend towards rich, white (or asian) families, who generally will have less children.

There's definitely not enough information to infer that first-borns are any different.

Well, I mentioned this study to a friend, and he made a good point:

The metric in the study is how many messages women send to men. If you're a taller woman, you likely will not message men who are shorter than you.

So, if you're taller, you have a bigger pool of women who would end up messaging you, which may account for much of the difference.

If you don't care too much about the theory and just want to get up and running, you should read:

http://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdf

And libsvm is probably the most widely used svm library:

http://www.csie.ntu.edu.tw/~cjlin/libsvm/

The author of the above paper and library is the same one giving the lecture in the OP's third link.

There are far better methods than the one linked in the article.

You can train a covariance matrix such that you can get a better distance metric. Particularly, you would use the Mahalanobis Distance:

http://en.wikipedia.org/wiki/Mahalanobis_distance

For classification tasks, there are two good ways of training a covariance matrix for distance metrics: neighborhood components analysis and large margin nearest neighbors.

The effect in the article is just a particular quirk of using the euclidean distance. You could, for example, get the same result by using a 1-norm distance.

Almost all of the fish oil you can buy actually comes from 1 company and have been tested for mercury (by ConsumerLab.com and Consumer Reports):

http://www.usatoday.com/news/health/2004-12-15-fish-oil-usat...

None of the major brands had significant amounts of mercury.

I'd just get the cheapest kind, given that it's likely from the same company.

If you have a statistics background, it's pretty easy to tell that it's significant given the numbers (2 of 41 in the fish oil group and 11 of 40 in the placebo).

The exact p-value is in the paper (0.007), or very significant. It's often difficult to get those kind of p-values in real world settings:

http://archpsyc.ama-assn.org/cgi/content/abstract/67/2/146?l...

A white Y using a standard font on an orange background isn't a hugely original logo.

It's quite conceivable that they came up with it themselves given the topic of the book.

I'd like to promote my python library for Cassandra:

http://github.com/vomjom/pycassa

There's also the possibility that hybrid drivers simply drive more often because their cost per mile is cheaper.

It's almost always better to teach the concrete and practical before the abstract.

That's like teaching the rules of grammar before teaching them to read and write.

That's not completely true.

Spending increases the velocity of money ( http://en.wikipedia.org/wiki/Velocity_of_money ) which can, in the short term, increase employment.

Please elaborate on why RingCentral should be avoided. I've never had any serious problems, although I'm wondering if I'm missing something.