Near plans to build world’s largest 1.4T parameter open-source AI model
Near Protocol unveils plans for the world’s largest open-source AI model, using crowdsourced research and aiming to decentralize AI tech.
Near Protocol has unveiled an ambitious plan to build the world’s largest open-source artificial intelligence model on the opening day of its Redacted conference in Bangkok, Thailand. The 1.4 trillion parameter model would be 3.5 times bigger than Meta’s current open-source Llama model.
It will be created through competitive crowdsourced research and development from thousands of contributors on the new Near AI Research hub, with participants able to join the training of a small 500 million parameter model from today, Nov. 10.
Near Protocol’s ambitious AI model
The project will grow in size and sophistication across seven models, with only the best contributors making the leap to working on progressively more complex and larger models. The models will be monetized and privacy will be preserved via the use of encrypted Trusted Execution Environments to reward contributors and encourage constant updating as the technology progresses.
The expensive training and compute will be funded with token sales, Near Protocol co-founder Illia Polosukhin told Cointelegraph at the Redacted conference in Bangkok.
“It costs about $160 million, so it’s a lot, obviously, but actually, in crypto, it is raiseable money,” he said. Polosukhin added:
“Then the tokenholders get repaid from all the inferences that happen when this model is used. So we have a business model, we have a way to monetize it, we have a way to raise money, and we have a way to put this in a loop. And so people can actually reinvest back into the next model as well.”
Article
Near patches critical bug that could crash every node on the network
Blockchain security firm Zellic discovered a flaw that could have crashed the NEAR network, but the team patched the vulnerability.
The smart contract platform Near Protocol contained a weird vulnerability that could have allowed an attacker to crash every node on the network, effectively shutting it down.
#near #blockchain #network #patch
According to a Sept. 26 report from blockchain security firm Zellic, which discovered it, the vulnerability was quietly eliminated through a patch in January, but some networks may still contain similar flaws.
In the report, Zellic referred to the flaw as a “Web3 Ping of Death” due to its ability to bring down an entire network “in an instant.”
Researchers discovered it while investigating Near’s peer-to-peer networking protocol for validator nodes, which allows its validators to communicate effectively with each other.
Nodes on the network communicate and authenticate each other via a “handshake” containing one of two types of signatures, Ed25519 and SECP256K1.
While verifying the signature for Ed25519 worked fine, verifying SECP256K1 signatures resulted in a “panic” response that crashed the node.
Having discovered this flaw, the researchers were surprised that it had not either been caught previously in tests or else crashed the network already.
The reason was more good luck than good management. It turns out that Near node software has “no code path that allows a Near node to generate SECP256K1 type keys.” In other words, the software allowed nodes to accept SECP256K signatures but didn’t allow them to produce such signatures.
As a result, no node had ever accidentally crashed the network by creating SECP256K keys and attempting to connect to another node.
Even so, a malicious node could alter the software to allow SECP256K keys to be generated. Once they did, they would have the power to crash any Near node simply by attempting to connect to it. The result could take down the entire network, constituting a “Web3 Ping of Death.”
To prove that the vulnerability was real, the researchers first created a version of the Near software containing a malicious patch that allowed SECP256K keys to be generated.
They then launched two nodes on a private testnet version of Near. The first node ran the legitimate software provided by developers, while the second ran the malicious version.
After the first node began producing blocks, the second node attempted to crash the first one by exploiting the two vulnerabilities. They found that the malicious node succeeded at crashing the legitimate one every time.