HN user
An aside: the text-only version of the NPR website is wonderfully clear and legible. Here is the original article in the text version: https://text.npr.org/2020/12/15/944184405/1st-patients-to-ge...
For something searchable, see “Baumol’s cost disease.”
Nitpick, but undergraduate enrollment is over 31,000 (as of fall '19 [1]).
[1] https://opa.berkeley.edu/campus-data/uc-berkeley-quick-facts
On the contrary, "dark silicon" instead suggests that separating fp32 and int32 (now in GA102/104, fp32 and int32/fp32) data paths at the cost of more die space usage currently makes excellent sense. (See also: tensor cores, ray tracing cores.) Jensen Huang very briefly alluded to this when during the GA102/104 announcement he mentioned the end of Dennard scaling.
Direct URL to one of the combined AQI maps for the Bay Area:
https://files.airnowtech.org/airnow/today/cur_aqi_sanfrancis...
Would be glorious if at some point they also released sources for the voxel RTS's (Tiberian Sun, RA2).
Fun fact: Alex Krizhevsky's cuda-convnet was also an early adopter of CHWN tensor layout. Basically, having the batch size N as the major dimension limits you to running batch sizes that are multiples of the warp size (typically 32), but then you also have an easier time of implementing fast kernels for all your neural and tensor ops, including tensor convolutions, without getting nearly as stuck in the weeds of microarchitectural optimizations.
rustc does have a working nvptx target today, though it’s not supported nearly as well as the mainstream cpu targets, and some things you would really want for gpu programming (e.g. shared memory address space) are not currently exposed in the rust language. But kernels written in rust can compile to ptx; you’ll still need to write glue code.
In fact, one of the motivating applications of PageRank was to bridge academic citation analysis to the web:
Her short story collections are quite accessible. If you want to dive into the Hainish cycle, _Four Ways to Forgiveness. Or for a mostly Hainish but more diverse set of stories, _The Wind's Twelve Quarters_.
I first learned about calculus from, I think, this book, "Calculus the Easy Way" [1] (or, at least the first chapter or two). It does make use of some algebra, but you're not necessarily limited to the strict progression of pre-algebra -> algebra -> calculus.
[1] (amazon: https://www.amazon.com/Calculus-Easy-Way-Douglas-Downing/dp/...)
$2250/month was c. 2015-2016 for EECS GSRs (during the semester)
NB: article was written December 2014. 1970 is now 50 years ago.
Prof. Matsuzawa, through his cognitive research of chimpanzee Ai
I had to do a double take there.
Due to the complexity involved, Cerebras is not only designing the chip, but they also must design the full system. ... The WSE will come in 15U units with a chassis for the WSE and another one for the power and miscellaneous components. The final product is intended to act like any other network-attached accelerator over a 100 GbE.
So it's NIC bandwidth bottlenecked. Though 100 GbE is in the same ballpark as PCIe 3, but last I heard 40-100 GbE were pretty CPU-intensive compared to alternatives.
Cool to see this on HN. I briefly worked there on a closely related project during high school after this paper was published. It was my first real experience doing wet lab work-- learned a bunch, met cool people, was fun. (Also did a lot of pipetting and PCR.)
To expand a bit, as I understand it, Remora gives a type system (and type inference) to APL- and J-style reranking, which is called rank polymorphism in Remora. The key thing is that type inference in Remora is based on Presburger arithmetic (0,+) which is decidable, unlike the stronger but overly powerful (for their purposes) than full Peano arithmetic (0,1,+,*).
Spoiler, ish:
The last time I measured ImageNet JPEGs with EXIF orientation metadata, the number of affected images was actually quite small (< 100, out of a dataset of 1.28M). There are also some duplicates, but altogether it seems fairly "clean."
Bonus round:
(1) Find the ImageNet (ILSVRC2012) images possessing EXIF orientation metadata.
(2) Of those images, find which ones have the "correct" EXIF orientation.
Not the most explanatory sources but function spaces essentially are vector spaces:
Have you looked into SageMath? (Technically it's "Python-based" rather than "just" Python.) I'm also curious if you're specifically looking for something in Python, or if doing symbolic computation/computer algebra in other languages would work for you, barring license costs.
One counterexample: https://arxiv.org/abs/1509.09308v1
Pratt parsing is great. Quoting from the original paper itself:
One may wonder why such an "obviously" utopian approach has not been generally adopted already. I suspect the root cause ... is our universal preoccupation with BNF grammars and their various offspring...
If you have an assembler or C compiler you can implement matrix multiplication (GEMM) which usually does most of the heavy lifting in your neural net. Now you correctly alluded that it may not be simple to efficiently implement GEMM but if you have a simple architecture without a complex memory hierarchy then using whatever SIMD facilities are available and some standard tricks will get you in ballpark of peak FLOP/s.
Or, just download a fast BLAS from your hardware vendor...
I'm curious if you have a particular language/microcontroller/microwave/badger you have in mind? Depending on which, YMMV.
In the Bay Area today, a section of Amtrak's Capital Corridor passes through the salt ponds and the Baylands marshes which is also quite reminiscent.
arXiv started out with physics preprints.
I'm not sure that there's a mature Rust alternative to "all of the above" quite yet. Some things that I've had to build for my own work (not always "built," sometimes I just wrote FFI bindings) include:
* N-D dense arrays, fashionably simply called tensors these days ;) (this I wrote from scratch to suit my own needs, but there are several implementations of this in Rust, as well as in C++)
* linear algebra (bindings to BLAS, LAPACK etc.)
* numerical integration (bindings to GSL or QUADPACK)
* optimization and machine learning (this I work on day-to-day)
* neural networks (I also work on this)
* multicore/manycore/GPU/distributed support (and this)
There's also the more practical aspects of using Pandas/iPython (Jupyter)/Spark for data science, including ETL, interactive work, and plotting, which IMO are not quite there yet in the Rust ecosystem. But I think that a lot of the pieces are there, e.g. bleeding fast CSV parsing libraries (https://github.com/BurntSushi/rust-csv), and what's left is the important last mile of bringing these things together in ergonomic libraries or frameworks.
Rust has been pretty critical to me for getting my work up and running with minimal debugging (I'm in CS grad school, working on deep learning and optimization). I'm super productive programming in Rust, which is also generally a pleasure to write in.
Just last week I had to land a pretty major refactoring (swapping out a single wrapper type for a differentiable "operator" with an implicit operator graph instead). It basically just worked out of the box as soon as I got it to compile. Definitely something to be said for working _with_ the compiler and its messages on moving, borrowing, mutability etc. (Incidentally, if I had to program exclusively in C++11/14, thanks to Rust I'd have become much better at programming in C++.)