The guts of the Google search engine are basically like a big table that turns your search question into a ranking of websites.

The guts of ChatGPT are like a colossal equation that takes the history of your conversation with it and computers the next response.

Both work on standard computing architecture, not quantum computers.

Actually the opposite. Stats is how you design studies, which is what governments, the economy, pharma, the medical field, and most sciences run on.

ML is just used for predictive modeling in low-stakes situations and fun tech demos.

ChatGPT is good at syntax, but it's worse than pretty much any rule-based system at logic or arithmetic. So depending on your task, something like IBM Watson could be considered more advanced because it has dedicated rule-based reasoning. All it takes for MS or Google to make a "more advanced" system is just couple a large language model with a logic engine.

There are a few things pay for when you buy proprietary software licenses:

• Product support
• Quality control (E.g. any procedure that makes it into SAS is rigorously QC'd, whereas anyone can publish a package to PyPI and the only way to tell if it does what it says is to do the QC yourself.)
• A license to profit off what you do with the software

Proprietary software isn't for everyone, but it has its place.

It is a convention, but there is a reason to prefer this convention to one where you add first, which is that multiplication distributes over addition, but not the other way around:

(1 + 2) x 3 is (1 x 3) + (2 x 3), but 1+ (2 x 3) is not (1 + 2) x (1 + 3).

That means that a lot of expressions where sums and products appear, like polynomials, would require using more parentheses if we were to write in a system that adds first.

Performing products first also keeps things consistent when working with units in equations: 50 meters + 10 meters = 60 meters, "meters" can be seen as a thing that gets multiplied by 50 and 10 and 60. If you added first you'd need parentheses to write that.

Control structures like if/else statements, while loops, and for loops place the code that is executed when the condition is true or false in predictable places, and more importantly, (unless there was an early return or a thrown exception), the control flow always returns to the line after the end of the (for example if/else) block when the conditional part is done. Goto has no such guarantees: it could send you to some arbitrary line earlier or later in the code and the only way to figure out if you ever come back is to go see if some other goto sends you back. Using gotos also means that there could be parts of your code that don't really make sense unless you know what gotos send you there.

As a result, gotos can make your code very hard to understand by inspection, and it also means that it's easier to make mistakes when writing code with gotos. That's not to say that it would be impossible to write readable code with gotos, but if you put all your conditional logic in predictable patterns, you're probably structuring it the same way you would using if or while statements anyway.

Yeah, your PPO and HDHP are priced unusually closely. With my employer the difference between them is $60 per month.

Is there an employer contribution? That could make up the difference. Also, if you can knock yourself into a lower tax bracket by contributing more to the HSA that could be worth something. Otherwise, I agree with your assessment.

It's "good" for visualization in the sense that it can give you something to look at, but it's not really good for visualization. You can't even guarantee that the nearest neighbor of a point in the projection is its nearest neighbor in the input space.

This paper demonstrates that you can make the output look like anything you want and still minimize the UMAP/tSNE objectives: https://www.biorxiv.org/content/10.1101/2021.08.25.457696v3

They've been used for that, but they really really shouldn't.

As u/ZombieRickyB said, the short answer is that it distorts distances to the point that you can't rely on them in downstream clustering.

There are two papers that do a really good deep dive into it:

This one: https://www.biorxiv.org/content/10.1101/2021.08.25.457696v1 where they both show that the distances pretty much have to be distorted and that the minimizer of the objective is such that you can make the output look pretty much like anything while minimizing.

And this one: https://jmlr.org/papers/volume22/20-1061/20-1061.pdf that studies which aspects of the objective functions of these methods affect the structure at different scales.

For dimensionality reduction to feed into other computational tasks like classification/clustering SOTA is to use data-specific NNs: autoencoders, [thing]2vec, transformer embeddings, graph embeddings, stuff like that.

UMAP is nice for visualization but you should pretty much never do any downstream computational analysis (like clustering) on the output.

That said, there are plenty of cases where PCA does a good enough job and anything more complicated isn't worth the loss of interpretability and theoretical elegance.

Yes, the premise of the thought experiment is that the man doesn't understand Chinese but the system "appears" to understand Chinese. This is used to argue that because the man doesn't understand Chinese, the apparent "understanding" is not "real." What I'm saying is that the reason the man doesn't understand Chinese is that the level of abstraction of which he's conscious of is not the level at which understanding happens, and I'm asserting that this is not a convincing argument against the system "truly" understanding Chinese as a whole.

>"Why not?" Because the formal symbol manipulations by themselves don't have any intentionality; they are quite meaningless; they aren't even symbol manipulations, since the symbols don't symbolize anything. In the linguistic jargon, they have only a syntax but no semantics. Such intentionality as computers appear to have is solely in the minds of those who program them and those who use them, those who send in the input and those who interpret the output.

This, I think, again falls into the same fallacy of trying to ellicit understanding from the rule-following machinery. The rule-following machinery operates on meaningless symbols, just as humans operate on meaningless physical and chemical stimuli. If understanding arises in a program, it is not going to happen at the level of abstraction to which Searle is repeatedly returning.

​

>The point Searle is trying to make is that understanding is not exhausively constituitive of some formal relations but it also depends on how the formal relations are physically realized

This also seems like an exceptionally weak argument, since it suggests that a sufficiently accurate physics simulation of a human would, after all, hit all of Searle's criteria and be capable of understanding. Again, even here, it is important to separate levels of abstraction: the physics engine is not capable of understanding, but the simulated human is.

One could, of course, stubbornly insist that without us recognizing the agency of the simulated human, it is just another meaningless collection of symbols that follows the formal rules of the simulation, but that would be no different from viewing a flesh-and-blood human as a collection of atoms that meaninglessly follows the laws of physics.

Ultimately in these "AI can't do X" arguments there is a consistent failure to apply the same standards to both machines and humans, and, as you point out, a failure to provide falsifiable definitions for the "uniquely human" qualities being tested, be it understanding, qualia, originality, or what have you.

The fallacy in the Chinese room argument in essence is that it incorrectly assumes that the rule-following machinery must be capable of understanding in order for the whole system to be capable of understanding.

We know that humans understand things. We also know that at a much lower level, a human is a system of chemical reactions. Chemical reactions are the rule-following machinery: they are strictly governed by mathematics. The chemical reactions don't understand things, but humans do.

There is actually no good argument that the Chinese room system as a whole doesn't understand Chinese, even though the man inside the room doesn't understand Chinese.

If you want an overview that gives a unifying picture I found this talk really helpful: https://www.youtube.com/watch?v=uF53xsT7mjc

Yes, most GNN variants need node features and the graph adjacency, some also take edge features.

This repo has a nice hands-on walkthrough: https://github.com/gordicaleksa/pytorch-GAT

Well, in CS theory is mathematical, and mathematical theory cannot be wrong because it's logically derived and makes statements about conclusions that can be made if certain conditions are met. So it would be nonsensical to discuss cases where such a theory is wrong. It stands to reason that the only practical discussion of deviation of practice from theory occurs in the realm of what you call misuse.

Your theory about what it means for theory to deviate from practice seems to deviate from practice.

You don't need to publish anything for there to be a citable object: just mint a doi for a GitHub release.

There are a few names for that including image captioning, (automatic) scene recognition, scene classification, scene analysis. It's a much older task than image generation from text so there are quite a lot of papers about it.