TTPrograms

Effective research is not always published. There are volumes of private research in technical disciplines you will never hear about. There is not enough data available for you to declare confidently that the PhD is a strong requirement for real research. Furthermore, especially in the field of computer science, you should really run the numbers on how many of ex. the 10 authors on each of the 100 Google papers put out each year had a PhD.

Additionally, nothing has been done to separate the issue of correlation and causation. If research capable individuals pursue a PhD because it interests them, who's to say that their research capability came from the PhD versus it being intrinsic.

One can learn a lot from a PhD. But saying that it's a practical requirement for research in this modern era of information access is without definitive evidence.

You don't need a PhD to do research. All information is free now. It's fully possible for individuals to self teach in a working environment and be capable of performing effective research with 2-4 years of good experience after undergrad. To assume that the only way to accomplish this is via PhD is silly. This is especially the case when talking about computer science fields, where the barrier to entry is basically owning a cell phone.

Voting has nothing to do with it, let alone votes per person. PoS doesn't require a voting system as EoS has implemented. The problem is having transaction inclusion decided by individuals that are voted in. It's analogous to having a democratic-republic government running a computer program.

> so one of the factors in the Drake equation (or one we should have put in) is responsible

The paper exactly explains why this is not the case. This is demonstrated using undergraduate level Bayesian probability.

This response is one of many when this work comes up on HN that would benefit from a basic understanding of multivariate probability.

EOS's issues are due to its convoluted governance structure, not POS.

I agree the example is weird, but that's literally what the paper says:

"In the training phase, it takes as input an encrypted training data and outputs an encrypted model without using the decryption key. In the prediction phase, it uses the encrypted model to predict results on new encrypted data." Figure 1 further implies that the results must be decrypted.

This is the typical operational setting of homomorphic ML.

I don't think you can apply the model (with unencrypted outputs) without all the decryption keys.

It's also just inference, not training.

It might be of some general interest to note that there exist such objects - distributions over distributions, or metaprobabilities. They have practical use - for example, if you are playing a game with uncertainty, you might observe something in the next step that changes your belief, or distribution over world state, b = P(s). If you have some expected distribution of next observations then you can talk about the probability of having some belief in the next state. Roughly P(b'|b) = P(P(s')|P(s)). You can collapse this into simple probabilities if you just care about your new observations, P(obs'|b) = \sum_s P(obs'|s)P(s|b).

I could imagine some frameworks where confidence intervals in this way would be useful - ex. I have 3 fairly different world models that I think are equally likely, each has a P(election), what's the P(election|world) and get confidence intervals across world models rather than just summing over them to P(election). But I agree that for most common approaches that simple probabilities are most useful and clear.

The latest update indicates that in fact they do have to agree to monetize their videos.

That's exactly what valuation is.

>The only people who do it well enough are PHDs

This is really untrue. Maybe that's part of your hiring issue.

This paper exactly accounts for the increased uncertainty due to multiplying these factors together. It's unclear to me how that makes it invalid...

How is the premise of monte carlo analysis flawed because "of course multiplying together..."? Monte carlo is just a way to estimate the total distribution of the resulting drake probability given uncertainties about the other values. The resulting distribution they depict is just the distribution of outcomes according to our uncertainties. It's precisely bayesian using the empirical estimates according to the literature.

The lesson is rather that optional static typing is useful. The programmer should be able to choose based on what makes sense for the task. Strictly statically typed languages preclude the option of going dynamic.

This is not completely true - they provide labelled poses as part of the training set. The differences are really minor.

Is that controlled for measures of merit? Or is that the accidental effect of correlation between ex. academic performance and socioeconomic status?

I'm surprised people are so blown away by this. It's a cool demonstration, but for this problem you have basically infinite training data. If you can find a latent space of faces this is hardly a stretch, since you already have a fantastic notion of locality in your data (by perturbing the camera). The interesting thing is generalization, which they show in figure 3B and is... ok, I guess. It's not that surprising compared to any of the other VAE stuff people have done (see the morphing scenes, 3D face illumination / rendering and furniture stuff from 2 years ago, for instance). It's also not that surprising compared to ex. the generative scene model RL paper that came out a few months ago (with Doom and the driving game). IMO deep learning research has moved beyond "here's another set of points I can fit a curve to". It really feels like this publication was heavily driven by prestige when most of the innovative stuff was achieved by other groups 2 years ago or more.

Ex. how's this different from https://arxiv.org/pdf/1503.03167.pdf from 2015?

This would be a good opportunity for something like Alpha Go. Learn a heuristic function and then do tree search using the heuristic. You could start by hand-designing a heuristic and do best-first search to see how much better you do versus exhaustive exploration.

Yeah, that's right. I don't have any personal recommendations for materials, but the Andrew Ng course would likely be a good start.

The biggest value of ML here would likely be to create a more useful energy function. This could be informed either by object detection data or hand drawn "energy" masks.

The other big change that could be useful would be to go with a non-greedy approach. Say you want to scale down a crowd of people - how do you remove, say, one person from the crowd instead of removing "low-energy" strips from multiple people. The people in the crosswalk image sort of demonstrates the difficulty of using basic energy metrics there.

One interesting idea would be to use GANs - come up with some parameterized seam removal function (with number of seams a input) such that the resulting image is still highly probable under the data distribution. So you can't cut objects into weird shapes since there aren't images like that in the dataset.

If a blockchain forks you have copies on both forks. What are you talking about?

A privately owned centralized debt exchange company can go out of business.

It's code. If there's a bug it does what the bug says.

What happens when there's a disagreement with your program that prints "Hello W0rld"? It prints "Hello W0rld".

It's almost definitely not going to happen.

Utility scale batteries optimize for energy/$, not energy density or weight etc.

Your comparisons are totally irrelevant.

Naive question - wouldn't a lot of these issues be much better if passwords were (on top of server side processing) salted and hashed client-side? Then in principle you couldn't do these cross-site attacks where people reuse their passwords.

Yeah, super expensive for sure. But in principle possible - I'm sure there are smarter ways to do it. I could also see some users willing to pay ~$1K or more. A big company committed to high-security, open source firmware for their routers, for example, could benefit a lot by being able to demonstrate to their customers that they use a given (ideally highly readable for auditing purposes) source code and that the updates they receive really use that source. I don't think there's a means to enable that sort of cryptographic verification currently without every interested end user rebuilding the source.

One expensive way that would work would be to write a compiler in Solidity. There might be better ways involving breaking up the code and splitting it up between compute resources like on Golem. By the standards of common blockchain cryptographic security I'm pretty skeptical of SGX and the like.

Reproducible builds you can cryptographically verify without doing the building yourself.