HNHacker News
TopNewBestAskShowJobs

KenoFischer

4,368 karma · joined December 2, 2012

Julia Core Developer Co-Founder at Julia Computing

Reach me at keno@juliacomputing.com

submissionscomments
KenoFischer··on Femtolisp: A lightweight, robust, scheme-like Lisp implementation
Not that it matters much, but femtolisp is not a new project. The bulk of the code has been around for at least a decade.
KenoFischer··on AI Dungeon 2 costing over $10k/day to run on GCS/Colab
> If your users aren’t mostly in the cloud with you, than this strategy doesn’t help at all.

Sure, but in the situation in the linked tweet 100% of the users where in the same cloud, just in the wrong region. For julia, the distribution is much more mixed, which is why we have the fastly fallback, which works as a traditional CDN. Still caching locally in each of the clouds is useful as people often download a fresh tarball of nightly julia when they CI their packages, so the load from the clouds is quite high.

KenoFischer··on AI Dungeon 2 costing over $10k/day to run on GCS/Colab
The cloud providers all have public lists of their IP ranges, so there's a fastly ACL for each provider/zone pair and for matching IPs, some custom VCL serves a HTTP redirect to the HTTP url for the appropriate cloud provider's cloud storage solution (S3, GCS, etc.). On the VMs, these resolve to appropriate internal IPs to obtain data from the storage service without charge.
KenoFischer··on AI Dungeon 2 costing over $10k/day to run on GCS/Colab
Cloud bandwidth costs are a rip off. For this particular situation though, make sure to replicate your files across multiple buckets, one in each GCP zone, otherwise you incur the cross zone transfer costs. We do something similar to serve julia downloads, because it turns out that most downloads are from people running on the cloud (so we basically replicate our binaries to every cloud provider and then to every region for that cloud provider). Everything else then goes through fastly for us (we also use fastly to serve custom redirects if your request comes from one of aforementioned cloud providers). That works pretty well. You do have to monitor it though to make sure that load doesn't suddenly shift to a cloud provider you didn't account for. For example, after GitHub actions became widely used, we suddenly started seeing TB/day traffic from Azure, which we hadn't deployed any caches to, so our bandwidth utilization on Fastly shot through the roof. (Side note: Shout out to fastly for hosting our binaries for free!). Without the cloud provider caching setup, we'd probably be at similar $/day costs, but this way it's basically free (even without the free fastly service, we'd only be at ~$1000/month or so).
KenoFischer··on Microsoft is creating a new Rust-based programming language for secure coding
There is a common demand from people for extracting just a very concrete computation from a julia codebase and compiling it to a standalone library (or even just using it within an existing julia program, but guaranteeing certain allocation or real time behavior). For example, julia includes a pure julia implementation of libm, but we also maintain the openlibm C library, since we link it into some of our C dependencies that need good quality math functions. It would be nice just to compile the julia version and have it be a drop in replacement for the libm that can be linked. Of course for that you don't want the runtime, or GC or code generator. The challenge here is coming up with the right interfaces and abstractions to make this a feasible and useful thing, without splitting the community into those that care about it and those that don't. We've started some work in this direction, but it isn't really usable yet.
KenoFischer··on Show HN: Borg Voice Generator
I always liked the Borg voice in Voyager. It had the reverberating "many voices" feel, e.g. in https://youtu.be/4bkw69E_C4g
KenoFischer··on Debuggers Suck
Yes, the latter (mostly for various weird corner cases). Back in the Gallium.jl days we could actually debug the recorded julia code, but we haven't regained that capability yet.
KenoFischer··on Debuggers Suck
Another testimonial from me. I basically refuse to do any debugging on systems that rr doesn't run on unless there's a very good reason. I use rr extensively whenever there's a bug in Julia and I would singlehandedly credit it with a measurable increase in system stability due to it catching bugs we'd never have gotten otherwise. roc is one of the few people with both the vision and persistence to really improve the debugging experience.
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
> Or maybe there is a way to create ML models that produces output which only someone with the correct (private) key can understand.

Yes, that's what the blog post describes how to do.

KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
I'm still only guessing at the objection, but if it helps, the encryptions are randomized, so two different encryptions of the same value do not have the same ciphertext.
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
I'm assuming you're referring to private information retrieval (https://en.wikipedia.org/wiki/Private_information_retrieval), which is from the same field of research, but may or may not use the same techniques.
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
> Once the model is trained, I can run this on any data encrypted with key X and find out if the data contains a cat (with some degree of accuracy). I have no way of telling information outside the tags provided on the training data, but it still gives me, a person without the encryption key, the ability to identify any feature that's tagged in the training set on any un-tagged production set.

I think you're missing the fact that the predictions come back encrypted, so you don't learn anything unless you know the key. Also, in this particular example the model was trained on unencrypted data, but as discussed below, you can do either.

KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
Training is a lot tougher. Just doing one gradient update step isn't all that bad (although you may have to play with the loss function a bit, e.g. logit cross entropy is probably tough to evaluate). However, then you need to go and actually do all the steps and gradient updates, so you probably need some form of bootstrapping to be able to evaluate computations of that depth. Also, the use case is slightly less compelling. For training, you can probably get all the parties who have data to coordinate and evaluate an MPC more cheaply than you could with HE alone. I think it'll require a very compelling use case for somebody to go and think through what the best way to do it is and it'll probably depend on the specifics of the application (who has what data, and what are we willing to leak as we go along - e.g. it's a lot easier if you don't care about keeping the weights secret).
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
In a properly functioning HE scheme, the party doing the evaluation cannot obtain information about the encrypted data, even if they do the operation incorrectly. Without further measures, they can of course compute an incorrect value, which depending on the larger protocol can sometimes be an issue (e.g. consider the scenario where after decryption the client shares the prediction with the server for some reason - in that case, if the server sends the original image ciphertexts, instead of predictions, they can trick the client into decrypting the original image). There is also always the risk that whoever is choosing the instantiation of the cryptoscheme knows something you don't and picks weak parameters, but that's just all the usual attack modes on cryptographic schemes.
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
Yep, same research setting, though a different network. I don't at the moment remember all the details of CryptoNets, but IIRC they were doing batch size 8192 evaluations (i.e. just using each slot as an independent value and evaluating the code as if on scalars), which allows you to get away without the fancy ciphertext encoding magic that's described in the blog post (at the cost of high latency of course).
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
Yep, that's correct. With the minor caveat that we choose an ML model that's "easy" to evaluate using homomorphic encryption.
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
I may be missing the question, so let me know if I do, but the point here is just that the crypto system is asymmetric. There's three kinds of keys, public, private and evaluation (as usual you can derive the others from the private key). Whoever has the public key can encrypt, whoever has the private key can decrypt and evaluation may or may not need the evaluation keys depending on what you're computing. As for which ML models it works for, they theoretical answer is all of them, because you can do arbitrary computation. The practical answer is that currently models of this complexity are probably the best you can do, because everything else would take years to run. It's being worked on though, both in theory land and in the implementation.
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
The CKKS paper that describes the crypto scheme I'm using is described here: [1]. The paper is decently readable, but frankly I feel that it doesn't really convey much intuition and it's a bit hard to follow if you don't have an algebraic number theory background. Probably the correct thing to do is to read the original BGV paper [2], which is still quite technical of course, but at least doesn't implicitly assume all the development that has happened since then. Once you've gotten the basics, I have an overview that focuses more on the practical aspects of how it works in the documentation [3]. I've also written an overview of how CKKS works, in which I've tried to highlight what the two main ideas of CKKS are compared to earlier schemes [4]. Let me know if you were looking for something else.

[1] https://eprint.iacr.org/2016/421.pdf

[2] https://eprint.iacr.org/2011/277.pdf

[3] https://juliacomputing.github.io/ToyFHE.jl/dev/man/backgroun...

[4] https://juliacomputing.github.io/ToyFHE.jl/dev/man/ckks/

KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
About a minute or so for the batch of 64, but I haven't tuned the implementation yet (I just did enough work to get it down to a comfortable range of experimentation). The paper I linked (https://eprint.iacr.org/2018/1041.pdf) which uses the same model, but with a more optimized implementation cites 26ms amortized per image (in a batch of 64), so I would suspect I can get down to that with a day or two of optimization work if I wanted to (or just plug in their backend - but where's the fun in that).
KenoFischer··on Machine Learning on Encrypted Data Without Decrypting It
Just to clarify, homomorphic encryption does not expose patterns. At every point in the computation the ciphertexts are computationally indistinguishable from random. The result of evaluating the ML model will be an encrypted prediction that you then need to send back to whoever encrypted the data (or more precisely whoever has the key - doesn't need to be the same person) so they can decrypt and use the prediction.
KenoFischer··on Why does F = ma?
I'm not sure the question is particularly well posed, but I think the most coherent answer you'd get from modern physics is symmetry. Restating Newton's law's slightly, you basically get two points:

1. Momentum is conserved

2. All interactions between objects are mediated by forces (i.e. interactions exchange momentum).

So you may ask, ok, but why do these two things happen, which is is where symmetry comes in. If you require that your theory is invariant under translations in space and time, your theory must conserve momentum and energy. Then you ask, ok, so what kind of long-range interactions can we have between particles in a theory where energy and momentum are conserved and the answer turns out to be, well those that exchange momentum. For example, in the hypothetical from the blog post where interactions are mediated by exchanges of acceleration (forces are proportional to jerks), you end up with a universe where absent interactions, acceleration is constant. Why is this inconsistent with symmetry? Well, in such a universe, the acceleration of particles would be constant in the absence of interaction, so their kinetic energy would keep growing and growing, violating conservation of energy.

KenoFischer··on Fully Homomorphic Encryption Using Ideal Lattices (2009) [pdf]
Depends on the scheme and your security parameters. The best known ones we have are probably 5-6 orders of magnitude slower than plaintext in the best case (obviously the worst case is much worse).
KenoFischer··on A lattice-based cryptographic library in Go
Yes, you are correct, the C++ libraries in this field have decent performance, but generally haven't been tuned to hell yet (though they do tend to use all the algorithmic tricks people know about). Which is good news for those of us writing non-C++ versions of these algorithms because it means state of the art performance isn't all that hard to achieve.
KenoFischer··on A lattice-based cryptographic library in Go
That's just a fancy way of referencing a particular paper. None of those terms mean anything outside this particular subfield.
KenoFischer··on V-Mail
I was confused by this also, especially since it seems unlikely to be able to locally procure paper in the middle of a warzone. However I do think it probably.makes logistical sense since you can pre-stock the paper (e.g. on a ship) or ship it with a much higher-latency mode of transportation (e.g. ocean freight).
KenoFischer··on High-Performance GPU Computing in the Julia Programming Language (2017)
Well, one problem is that you're reading an NVIDIA marketing post on an NVIDIA blog talking in particular about the lowest levels of the stack targeting NVIDIA hardware. Higher level abstractions can and do just work across different hardware backends (not as well as we'd like, but we have some thoughts on how to improve that).
KenoFischer··on Show HN: Bel
Julia has explicit parameterization, but will also interprocedurally propagate known field values at compile time if known (which happens a lot more because our compile time is later), even if they weren't explicitly parameterized. Since this is so useful (e.g. as you say for dimensions of nd arrays - particularly in machine learning), there's been some talk of adding explicit mechanisms to control the implicit specialization also.
KenoFischer··on Critical Security Issue Identified in iTerm2
Try https://github.com/skaji/remote-pbcopy-iterm2
KenoFischer··on Julia Academy: Learn ML, Parallel Programming, Julia and More
Sorry about that. I've let the team know and they'll be taking a look shortly once folks are awake. Not sure what happened here, the site was up fine until now.
KenoFischer··on Supermicro server BMCs left exposed to remote attack by any USB device
While this is a good best practice, most current BMCs treat the host as trusted, so if BMCs assume the management network it's trusted, you've just provided a path to pwn every machine on your network if only one of them is compromised. So while that's of course a good best practice, it isn't the be-all-end-all of C security (The same point was made during the presentation on this vulnerability at OSFC this morning).
← PreviousPage 8 of 17Next →