bwasti

Mining Bitcoin can be done with pencil, paper and the ability to communicate with others also interested in Bitcoin.

A popular post on r/wallstreetbets[1] summarizes Michael Burry’s thesis that CPI (consumer price index) is unaffected as long as inflation isn’t directly impacting consumers of the bag of goods that make up CPI. When there are fewer jobs, these consumers aren’t able to influence the prices of these goods (because they aren’t being paid inflated wages), and the metric commonly used to evaluate inflation is unchanged.

[1] https://www.reddit.com/r/wallstreetbets/comments/lr8h1v/why_...

I've posted this once before but I grabbed a domain name and preloaded a tutorial. Happy to remove if that's against the rules!

The source can be found here: https://github.com/bwasti/mebm

It can also handle nonlinear conversions such as Fahrenheit to Celsius

huh?

You can just try the instructions with an off-the-shelf assembler. They're not supported.

I've found the M1's 128bit instructions to be quite fast. My M1 MacBook Air can hit 90GFlops on a single core. My 2019 16" MacBook Pro is only 1.5 times faster at 135GFlops per core, despite double the vector width.

Benchmark here: https://github.com/bwasti/mac_benchmark

If anyone has the new 2020 MBP with AVX512 I'll update the benchmark to include avx512 instructions! I'm very curious about those numbers

I believe problems solved by this tool generally disappear when using named tensors

perhaps title "Sweatpants Forever: How the Fashion Industry Collapsed" for context?

would a library like pybind (for C++ extensions) be compatible with the philosophy of this python implementation?

this can be done in browser with tensorflow.js + a pretrained mobilenet in a couple dozen lines of code

example: https://jott.live/html/tfjsmobilenet code: https://jott.live/code/tfjsmobilenet

Note that this a layout trick and not an algorithmic one. An algorithmic speed up that is good for dense convolutions with small kernels is to use Winograd: https://arxiv.org/abs/1509.09308 For large kernels, implementing an FFT tends to help.

Also worth keeping in mind that many modern networks use depthwise separable convolutions, which are channel wise convolutions (skipping a reduction over the channels, which is a memory bound operation) followed by 1x1 convolutions (which are exactly matrix multiplications with no im2col step).

Why not use tensorflow.js or onnx.js and just do this in the browser/locally? Models have gotten good and this type of classification is very cheap these days. Hitting the network for such a small task is very much overkill

I wrote a small piece that might provide some intuition on the usefulness of VCG auctions https://medium.com/@bwasti/mechanism-design-a8ff1b1a7bdd

I think that link expired and now shows the wrong games. Here's a link to the final game between LC0 and Stockfish https://cd.tcecbeta.club/archive.html?season=15&div=sf&game=...

fair point,

2016 - 1 total from math and engineering

https://www.cmu.edu/career/documents/2016_one_pagers/cit/ece...

https://www.cmu.edu/career/documents/2016_one_pagers/mcs/mat...

2018 - 4 total from math and engineering

https://www.cmu.edu/career/documents/2018_one_pagers/cit/ECE...

https://www.cmu.edu/career/documents/2018_one_pagers/mcs/1-P...

If you're curious to do some more research, here's the link https://www.cmu.edu/career/about-us/salaries_and_destination...

I wrote one article on Medium. I ended up writing my own little version using open source markdown rendering to see how hard it would be to roll my own, https://jott.live

From what I found, there is a lot of stuff Medium does well that is hard to recreate by one's self. Super simple features, like

- rich text editing that isn't ugly

- caching what you're currently working on

- tracking views and who has viewed your article

aren't easy to build and generally aren't worth it unless you write many many articles.

Although I don't like the aggressive account on-boarding and payment models for reading articles, Medium certainly makes life easy for writing articles.

I'm not sure how the journalist fact checked this, but in 2016 CMU sent 12 people to Facebook[1]. In 2018 CMU sent 27 people to Facebook[2].

[1] https://www.cmu.edu/career/documents/2016_one_pagers/scs/scs... [2] https://www.cmu.edu/career/documents/2018_one_pagers/scs/1-P...

wow this is great! it uses the scroll wheel and mouse location. I had no idea the latter was possible - very inspiring

What aspects are broken?

Yea, it's certainly struggling. I don't know of any quick fixes, so I kicked off the service on more ports for now.

The pricing is a bit confusing:

€10/m for 100k queries €45/m for 300k queries

Can I just make 3 accounts and save €15/m?

You may want to check out Intel's optimized version of TensorFlow Serving[1] for further improvements (on the order of 2x for ResNet-50[2]).

As an aside, I took into account the resource allocation in the parent comment. The c5.2xlarge has 8 cores, 8GB RAM [3] and does a single fp32 inference in ~17ms. If we chop that down to 4 cores and assume linear scaling we can fathom running ResNet-50 in ~35ms compared to the ~500ms achieved here. I'd recommend comparing to a known baseline rather than a "vanilla setup" to ensure you aren't missing any simple changes that may dramatically improve performance.

[1] https://github.com/IntelAI/models/blob/master/docs/general/t...

[2] https://www.intel.ai/improving-tensorflow-inference-performa...

[3] https://aws.amazon.com/ec2/instance-types/c5/

containers are run on a 4 core, 15GB, Ubuntu 16.04 host machine

What CPU is being used?

Assuming the benchmark is done with something like an EC2 C5 instance, the results in this post are quite slow. Somewhere around 14x slower than benchmarks from a year ago on EC2 C5 instances. [1]

[1] https://dawn.cs.stanford.edu/benchmark/ImageNet/inference.ht..., using the c5.2xlarge benchmark and assuming linear scaling

Reminds me of a little project I did a while back, but instead reading from stdin like netcat

https://github.com/bwasti/webpipe

there’s a single algorithm (Tarjan’s) that actually solves all your graph needs. It returns a reverse topologically sorted DAG of strongly connected components

ah, the assumption is that even the remote call (for example, in the case of async) is pure

as long as configuration parameters remain fixed in the life of the execution it is still pure, right?

beyond memoization you can do cool stuff with scheduling if you annotate pure functions and execute lazily. I actually mocked this up a little while back https://github.com/bwasti/lazy

also just shared it here https://news.ycombinator.com/item?id=18080598 if you have comments

As well as tmux! But neither offer multiple cursor support.