wetherbeei's comments

Sounds similar to https://cloud.google.com/generative-ai-app-builder/docs/chec....

"The check grounding API returns an overall support score of 0 to 1, which indicates how much the answer candidate agrees with the given facts. The response also includes citations to the facts supporting each claim in the answer candidate.

Perfect grounding requires that every claim in the answer candidate must be supported by one or more of the given facts. In other words, the claim is wholly entailed by the facts. If the claim is only partially entailed, it is not considered grounded."

There's an example input and grounded output scores that shows how the model splits into claims, decides if the claim needs grounding, and the resulting entailment score for that claim in: https://cloud.google.com/generative-ai-app-builder/docs/chec...

We (I run Google Patents), generated them using Wsabie (https://research.google.com/pubs/archive/37180.pdf) trained on the set of words of the full text -> Cooperative Patent Classification codes. So summed word embeddings trained for a classification task, which works well on similarity too.

If you're interested in using patent data for AI, check out https://www.kaggle.com/bigquery/patents and https://www.kaggle.com/ostegm/plotting-similar-patents

I run Google Patents (patents.google.com) - we've thought about including a way to search by expired patents (we have the expiration indicators), but in my opinion it gives a false sense of security. There's also http://freeip.mtu.edu/home/index.php, which searches over only expired patents.

The patent in question could have been improved upon, and that improvement can still be in force. Say someone patents a widget A + B, and later files a continuation A + B + C (https://en.wikipedia.org/wiki/Continuing_patent_application). The first patent could be expired, but while building your copy of A + B you might come to the same conclusion that the invention also needs to include C (which is still in force) to actually work.

Google Patents focuses on improving patent quality. There's still uncertainty if a granted patent is actually valid. If we can improve the prior art finding process for inventors and examiners, then fewer overly-broad patents will be granted, and it will be easier to tell if an invention actually infringes a patent.

Then we can start to think about making patent information more useful for part of the original purpose - as a transfer of knowledge to the public domain in exchange for a temporary exclusive right.

I made a painless way to integrate native libraries into Java (Android NDK support too) with some automatic JNI generation [1]. It uses GWT's javascript comment syntax (edit: see [2] for examples).

[1] https://bitbucket.org/wetherbeei/acceljava

[2] https://bitbucket.org/wetherbeei/acceljava/src/4140d721c11b5...

I've been working on a tool (https://then.io) that solves all of these problems with the same effort that a todo list requires. Your tasks are scheduled between your calendar events and within the spans of time you set for them to be executed. They are ordered so that all of your due dates are met, with padding for mistakes.

Paradox of choice, lack of context, lack of commitment devices, and heterogeneous complexity are all solved by the nature of then.io. I would argue that priority doesn't matter, only due dates do. If you have too many tasks to finish before a due date, then you need to make the decision of which due date to push back.

With a set of true and false inputs you could evolve a regex:

https://www.lri.fr/~hansen/proceedings/2012/GECCO/companion/...

The author found the optimal solution when trying to construct these expressions: store them in a trie. Because the generated regular expressions match only the inputs, this solution may find a more compact way to test if the inputs have lots of overlap.

It would be cool if the inputs weren't matched exactly, and frak could figure out a general pattern for your inputs (decimals, capitalized words, etc). That could help newcomers with a starting expression that matches their inputs.

More from the Q&A:

Asked about if Snowden is a Patriot: "No he is not. I called for a thorough review of surveillance programs before Snowden leaks. A thoughtful, fact-based debate. I signed an executive order that provided protections for whistleblowers in the intelligence community, so there were better avenues for leaking information."

His "4 steps":

1. Work with congress to enact reforms to PATRIOT Act. He said the US is not allowed to listen to any phone calls without a warrant.

2. Work with congress to improve the public's confidence in FISA. Consider changes: a judge reviewing a request only hears one side of the story, but we could allow an outside party to defend civil liberties and privacy "in certain cases".

3. Be more transparent. Create a website to provide more transparency.

4. Form an outside group of intelligence experts to review surveillance technologies.

From the FAQ/Policy page [1]:

"Q: Can I run a server from my home? A: Our Terms of Service prohibit running a server. However, use of applications such as multi-player gaming, video-conferencing, home security and others which may include server capabilities but are being used for legal and non-commercial purposes are acceptable and encouraged."

[1] https://fiber.google.com/help/

"Such is modern computing: everything simple is made too complicated because it’s easy to fiddle with; everything complicated stays complicated because it’s hard to fix." - Rob Pike

The point is your code is very verbose compared to the original, and anyone will take at least twice as long trying to figure out the interaction between channels and goroutine launches vs the sequential version.

for i, v := range a { a[i] = process(v) }

You can have redundant load balancer setups that listen on the same IP [1]. Combined with round-robin DNS and there isn't a single point of failure unless your DNS servers go down.

[1] http://siag.nu/pen/vrrpd-linux.shtml

Google Scratchpad Chrome Extension: https://chrome.google.com/webstore/detail/scratchpad/kjebfhg...

Distributed Hash Tables, but then you need to solve the security issues of secure bootstrapping, Sybil attacks, and partitioning.

I was aiming for the most secure implementation, assuming someone had control over many pieces of the puzzle/network.

This has been done many times before, and all rely on a trusted 3rd party to do what they say. I spent a few years on and off toying with this idea, and came up with a solution that does not need any 3rd party middleman to transmit keys or delete messages after a period of time.

If you want a real challenge, figure out how to do that.

As a researcher in Wen-Mei's group at UIUC and having taken this class, I can say this is one of the best classes for gaining practical knowledge of exactly how to parallelize and distribute massive computational problems across GPUs and multiple nodes. The knowledge is very applicable, and the machine problems are well thought out to introduce the common parallel operations and optimizations.

For the final project I replaced the NPC AI in Half-Life 2 so that the optimal position calculations ran on the GPU and took into account many more parameters than the CPU version.

Looking through the code, this seems to do the exact same thing as Aparapi. I'm surprised this was given funding given the high quality implementation AMD has put together.

The headline is misleading; only a small subset of Java can be ported to the GPU. It works great for inner math loops and such, but not for higher level problems. Even if the author managed to find a way to translate more complicated problems (I see object locking in the list of features), they would be better suited to run on a CPU, or refactored to avoid locks.