World Champion Magnus Carlsen and 11 more of the world's best chess players are competing in the Chessable Masters by chess24, the 3rd event in the $1 million Magnus Carlsen Chess Tour, taking place from June 20 to July 5.

Ding, Liren vs. Carlsen, Magnus

R Praggnanandhaa impressed everyone by becoming the second Indian chess player ever in history after the legendary Viswanathan Anand to reach the final of Chess World Cup. He defeated Fabiano Caruana 3.

Chess World Cup Final: A Look At R Praggnanandhaa's Record Against Magnus Carlsen

VOV.VN - Vietnamese chess player Le Quang Liem took the lead at the Grandmaster Triathlon in the Classical Biel International Chess Festival 2023, which was held in Switzerland on July 26.

Quang Liem wins Biel Grandmaster Triathlon for second consecutive time

Online Chess platform Chess.com has announced that its penultimate event of the 2023 Champions Chess Tour season will be sponsored by Swiss private bank Julius Baer. The event will be called the 2023 Julius Baer Generation Cup,

Swiss bank Julius Baer sponsors $235,000 Champions Chess Tour event

V. Praneeth became Telangana’s sixth and India’s 82nd Grandmaster when he outwitted GM Hand Niemann of the US in the penultimate round of the Baku Open 2023

Prraneeth is India’s 82nd Grandmaster

V. Prraneeth became Telangana’s sixth and India’s 82nd Grandmaster when he outwitted GM Hans Niemann of US in the penultimate round of Baku Open 2023. The win against Niemann helped Prraneeth cross 2500 in live elo ratings.

V. Prraneeth becomes India’s 82nd Grandmaster

Hikaru Nakamura blundered mate-in-1 as he lost 2.5:0.5 to Fabiano Caruana in the final of the Winners Bracket of the Chessable Masters. That’s not the end of the road for Hikaru, however, since he’ll get a second chance against either Magnus Carlsen ...

Nakamura blunders mate-in-1 | Chessable Masters 3

Wei Yi beat Harikrishna, Gawain Jones and David Anton to lead on 10/12 after Day 1 of the Chessable Masters, ahead of Ding Liren, Anish Giri and Magnus Carlsen, who all scored two wins and two draws. 13-year-old Abhimanyu Mishra, who’s vowed to break Wei ...

Chessable Masters 1: Wei Yi leads as 13-year-old Mishra stars

Wesley So ended day 1 of the Chessable Masters in clear first place on 4/5, with the chasing pack of Vladislav Artemiev, Hikaru Nakamura and Alireza Firouzja half a point back. One of Wesley’s wins was from a position where 12-year-old Abhimanyu Mishra ...

Chessable Masters 1: Wesley So top, Mishra’s baptism of fire

US Chess Champion Wesley So came from behind on the final day of the Chessable Masters to defeat Liem Quang Le and claim a record 3rd title on the Meltwater Champions Chess Tour. “My goal is just to force Magnus to show up!” he said of his hopes of ...

Wesley So triumphs in the Chessable Masters

Chessable

chessable

Would you leave a Google Staff Research Engineer role just because you want your TV to automatically pause when you get up to get a cup of tea? Actually, how is that even relevant, you might ask. Let’s see what Pete Warden, former Google Staff Research Engineer and now CEO and Founder of Useful Sensors, has to say about that. From Jetpac to Google and TinyML, from Google to AI in a Box Pete Warden wrote the world’s only mustache detection image processing algorithm. He also was the founder and CTO of startup Jetpac. He raised a Series A from Khosla Ventures, built a technical team, and created a unique data product that analyzed the pixel data of over 140 million photos from Instagram and turned them into in-depth guides for more than 5,000 cities around the world. Jetpac was acquired by Google in 2014, and Warden has been a Google Staff Research Engineer from then till March 2022. That’s when he founded , which he sees as the evolution of the work he’s been doing at Google. Warden was the Technical Lead of the TensorFlow Mobile team, responsible for deep learning on mobile and embedded devices. Useful Sensors . Naturally, much of what he did was based on things others were already working on: “A lot of my contribution has been helping publicize and document a bunch of these engineering practices that have emerged,” Warden said. Either way, is getting big, and Warden is a big part of it. Warden is sometimes credited as having kickstarted the TinyML subdomain of machine learning TinyML Tiny machine learning (TinyML) is broadly defined as a fast-growing field of machine learning technologies and applications, including hardware, algorithms, and software capable of performing on-device sensor data analytics at extremely low power, typically in the mW range and below, and hence enabling a variety of always-on use-cases and targeting battery operated devices. Useful Sensors just launched a product called , which it dubs an “offline, private, open source LLM for conversations and more.” Even though it’s not the first product Useful Sensors has created, it’s the first one that’s officially launched. That was a good opportunity to catch up with Warden and talk about what Useful Sensors is working on. AI in a Box Click to listen to the full conversation on the . here Orchestrate all the Things podcast Simplicity and the creepiness factor While it is true that Warden cited wanting his TV to automatically pause when he gets up to get a cup of tea as part of the reason why he started Useful Sensors, some context is definitely needed. Part of Warden’s motivation for his work on Tensorflow for embedded devices was to see it used in everyday objects. As Warden related, when he went to talk to companies that made light switches or TVs to tell them “all about this wonderful open source code that they could get for free, and all the conferences and documentation and examples and books,” they would hear him out. But then, in the end, they’d usually say something like: “That’s great. But we barely have a software engineering team, let alone a machine learning team. So can you just give us something that gives us a voice interface or tells us when somebody sits down in front of the TV”? That’s quite telling, and producing self-contained hardware is a valid reason to set out on a new venture. However, that’s not something Google itself could not achieve. Google Pixel, for example, already provides automatic captions running on-device for content that plays on the phone. But there’s something more: privacy and data sovereignty, aka “the creepiness factor”. AI-enhanced In a video hosted on the Useful Sensors home page, Warden mentions how, during his tenure at Google, he would often get questions about whether Google was spying on people. Those questions are valid ones, triggered by a widely observed phenomenon: when mentioning the topic XYZ in the vicinity of your phone, you will often get bombarded with ads about XYZ for days on end. Warden, on his part, swears that the code he was working on does not do that. But, he goes on to add, he has no way of proving that because the code is proprietary. Plus, we may add, there’s nothing anyone can say about other parts of Google’s codebase, or other apps for that matter. It’s hard to light-heartedly dismiss such a widely shared experience. Useful Sensors That brings us to the core of it all – what Useful Sensors does and how it’s different. The vision, as Warden put it, is to be able to run machine learning locally and to do it in a private and checkable way. Everything should run locally with no internet connection, so conversations and data are completely secure. No account, setup, or subscription needed. Warden shared that Useful Sensors has already launched the person sensor, a small board that provides and indication of whether there’s a person nearby, as well as a tiny QR code. Both run entirely locally and retail at $10 and $7, respectively, Warden said. But these products have something else in common too: they are aimed at makers, i.e., hobbyists with enough motivation and technical skills to tinker with them, but also at electronics vendors. As Warden shared, Useful Sensors is currently in talks with a number of electronics vendors. Useful Sensors products are being evaluated, and Warden is hopeful that it won’t be too long before they end up being included in devices sold in the market. In fact, that is the audience that holds the greatest promise for Useful Sensors. Its backers also see the potential, apparently, as the company has received $5 million in seed funding already. Warden co-founded Useful Sensors with CTO Manjunath Kudlur, formerly of Cerebras. Kudlur was the compiler team lead at Cerebras as well as one of the founders of Google’s TensorFlow and Nvidia’s CUDA. Warden said Kudlur contributes greatly to things such as accelerating transformer models for Useful Sensors. The team lists a total of 8 people at this point, but if their plans come to fruition, another funding round and growth are well within sight, as per Warden. AI in a Box, the product that Useful Sensors just launched, seems like it was designed to do a number of things. First, it can grow awareness for Useful Sensors, as it’s aimed at makers. As Warden said, people can tinker with the code, but it already does some useful things out of the box. It can provide live captions, as well as receive voice commands and translate between multiple major languages on the fly. AI in a Box can also help raise some cash for Useful Sensors. But perhaps more importantly, it positions Useful Sensors as an ecosystem provider. This seems like part of the vision for the company, and Warden shared that he’s hoping people will get creative with AI in the Box. In fact, he added, some examples of things people have built with Useful Sensors products already exist on . Hackster Under the hood AI in a Box features a RockChip 3588S SoC with an . The NPU is a unit specifically designed to accelerate neural networks, and the team was able to leverage it to enable a Large Language Model to run locally. AI in a Box is built on a foundation of open-source models like and . In the same vein, the company is releasing all the code to accelerate and control the system under an open-source license. NPU Whisper Llama2 Useful Sensors is also available. The idea is that transparency should help with security and privacy auditing, with Warden noting he’d be happy to have regulators audit Useful Sensors products. Releasing open-source code will also enable developers to use the system as a base to build their own real-time voice input applications in Python. library for optimized transformer inference on the RockChip NPU Warden said that once they were able to get the real-time speech-to-text working, there was lots of choices around which LLMs they could run locally. The team is also looking into doing some of its own fine-tuning, but they’ve been able to get a long way by just providing prompt contexts for interactions. As Warden noted, anybody who’s familiar with LLMs would probably easily recognize what Useful Sensors did. Real-time speech-to-text enables AI in a Box in a box to function as a keyboard too, among other things. By having an LLM in the mix, too, that opens up a range of possibilities. For example, LLMs are known to be able to interface with APIs. Warden mentioned Raspberry Pi as an example that could enable people to control a number of devices using voice commands. AI, innovation, empowerment An example of what people are already working on, Warden said, is an actor who is using the company’s person sensor to automate spotlight operation for solo performances. Rather than having to pay someone to operate a spotlight, the actor is hoping it should be possible to automate this. In a way, that’s a perfect metaphor for the double-edged sword that innovation and AI truly are. That may sound like a good idea for the actor, but what about the operator? “That’s that’s a really big question with anything around innovation. If we’re, quote unquote, making things more efficient, what are the societal impacts of that? A big part of what I’m trying to do is get these technologies into people’s hands so that it’s not just a bunch of engineers who are making these decisions about what we should do. People can try these models for themselves, and see, for example, how useful, but also how flawed the current generation of LLMs are. I don’t want us technocrats to be the ones making these decisions. I want a well informed public who are actually able to say – hey, this is what we want”, Warden said. That certainly sounds like a noble aspiration. How compatible it really is with VC backing, a cut-throat competitive landscape dominated by the Googles of the world, the public’s ability to elaborate its own take on things, and administrations’ willingness to take the public into account remains to be seen. Also published . here

Useful Sensors: Pioneering AI with AI in a Box, A Different Paradigm for Edge Computing

Yoshua Bengio Weighs in on the Pause and Building a World Model

Over the past year, we have seen an increase in layer two scaling solutions for Ethereum, with ZK-rollups being some of the most promising. Thanks to the Stark rollup, any decentralized application can achieve a limitless computing scale, which keeps the Ethereum network secure and stable. This is made feasible by the fact that the STARK cryptographic proof system, which is the most flexible and scalable of all cryptographic proof systems, is used by StarkNet. And Infura, Web3’s top node provider, now offers StarkNet compatibility through its node-providing service! By providing StarkNet RPC endpoints, Infura helps bridge the gap for Ethereum developers and facilitates a composable Web3 ecosystem. This article covers what StarkNet is, how it contributes to Ethereum scalability, and how developers can get started by launching a smart contract to the network using Infura. You also learn how to access StarkNet with Infura RPC endpoints and deploy your own ERC-20 tokens on the network. Ethereum Scaling Adding a bridge to a layer two network is one of the most effective strategies to maximize the value of crypto assets. Lower transaction fees, more throughput, and improved customer experience are all benefits of doing this. Rollups are some of the most widely used options for layer two scaling solutions. They function by processing transactions off-chain. They can also guarantee transaction data storage on the Ethereum chain, boosting layer one network security. create cryptographic proofs that demonstrate the legitimacy of a transaction. It's interesting to note that each batch of transactions would have a unique "validity proof" filed on the main chain. , on the other hand, assume that all transactions are valid and can submit batches of transactions without any calculations. Zero-knowledge rollups Optimistic rollups The ZK rollups' ability to assess transaction integrity would rely on cryptographic proofs. Conversely, the time between submitting the rollup and its acceptance on the base chain is difficult for optimistic rollups. StarkNet and STARKs is a permissionless decentralized ZK-rollup. It functions as an L2 network on top of Ethereum, allowing any dapp to reach an infinite scale for processing without affecting Ethereum's security and composability. StarkNet By utilizing , interactive oracle proofs (IOPs), and fast algebraic local coding protocols like FRI, StarkNet's cryptographic hashing functions are the quickest. They outperform all other ZK technology. quasi-linear probabilistically checkable proofs (PCPs) The Solidity to Cairo compiler also enables faster builds for Solidity developers using the ZK rollup, facilitating the use of established Solidity tools in the developer’s stack. StarkNet Endpoints with Infura Infura, a Web3 Infrastructure-as-a-Service (IaaS) provider, offers various services and tools for blockchain developers. The Infura Application Programming Interface (API) suite is part of this. Any project pushing a lot of traffic through the Ethereum network, or one that plans to, can benefit from Infura's modular scaling solutions. The network of hosted Ethereum clients, which supports mainnet and testnets via client-compatible JSON-RPC over HTTPS and WSS, is the most well-known component of the Infura infrastructure. StarkNet endpoints are now widely available and supported by Infura. StarkNet enables indefinite scalability of any commercial use case, backed by STARKs, the most potent zero-knowledge proofs in the Ethereum ecosystem. How To Launch a Project on StarkNet with Infura Prerequisites Before getting started, we need the following prerequisites: and its package manager NPM. Node.js Verify we have Node.js installed by using the following terminal command: node -v && npm -v An Infura account Basic understanding of JavaScript Create an Infura account to access the StarkNet network To access a StarkNet node and execute requests, we will need an Infura endpoint. Visit the Infura website to for a new account or if you already have one. sign up log in After successfully signing up, the page redirects to our dashboard, where we can create a new key, as shown below. Click the "Create a New Key" button and fill in the required information. Next, click the "MANAGE KEY" button, scroll down to the Starknet section, select Goerli network, and copy the URL. Building a project on StarkNet with Infura This section will build our application from scratch to implement account creation, deployment, minting, and transferring tokens. StarkNet Project setup and installation We'll create an empty project and install the library dependency using the following commands. starknet.js mkdir deploy-erc-20-token-with-starknet
cd deploy-erc-20-token-with-starknet
npm init -y
npm install starknet dotenv
touch index.js Next, create a file and paste the StarkNet URL we copied from our Infura dashboard. .env STARKNET_TESTNET_ENDPOINT=https://starknet-goerli.infura.io/v3/<API-KEY> Download the account contract ABI Head to the to download the contract ABI for and . contract folder in this repository ERC-20 OZAccount Create a new folder called . Then, create two new files inside the folder, and . contracts ERC20.json OZAccount.json Next, we will paste the contract ABI we copied into those files. Our project folder structure should look similar to what we have below. Setup provider We may communicate with the StarkNet network through the Provider API without signing any transactions or messages. We will set up a provider via the Infura API endpoint, but in some cases, we may also want to use the default provider. Inside the file, add the following code snippet. index.js import dotenv from "dotenv";
import fs from "fs";
import { Account, Contract, ec, json, stark, Provider, number } from "starknet";
import readline from "readline";

dotenv.config();

// Initialize provider
const url = process.env.STARKNET_TESTNET_ENDPOINT;

console.log("Using Infura Starknet provider: ", url);

const provider = new Provider({
  rpc: {
    nodeUrl: url,
  },
}); In the code snippet above, we Imported the , , and libraries starknet fs dotenv Initialized the provider URL Created a new instance of the from the library Provider starknet Generate private and public key pairs Since StarkNet does not support Externally Owned Accounts (EOA), all accounts on its network are contracts. In contrast to Ethereum, where public and private key pairs facilitate accounts, StarkNet accounts are the only means to sign transactions and communications and confirm signatures. Consequently, a Contract-Account interface is required. Let us generate public and private key pairs with the following code snippet. // Generate public and private key pair.
const privateKey = stark.randomAddress();

const starkKeyPair = ec.genKeyPair(privateKey);
const starkKeyPub = ec.getStarkKey(starkKeyPair);

// Log the Public and Private key pair.
console.log(`Private key: ${privateKey}`);
console.log(`Public key: ${starkKeyPub}`); To test our application in the next step and every step afterward, use the following command: node index We will use the command above each time we need to run the project locally. If you are getting a SyntaxError stating you can’t use the import statement outside of a module, add "type": "module" to your package.json file. Note: We should have something similar to the output below. Write down both keys in case we need to use them again for other procedures in the future. Never share your private keys with anyone, and keep them secure. Deploy a new account on StarkNet By utilizing the provider method and passing the previously produced public key as input, we can deploy the pre-compiled account contract to StarkNet. deployContract Add the following code snippet to deploy the account contract, and we will wait for it to be verified on StarkNet. //...

// Deploy the Account contract and wait for it to be verified on StarkNet.
console.log(
  `////////////////////////////////////////////////////////////////////////////////
    Deployment Tx - Account Contract to StarkNet...
   ////////////////////////////////////////////////////////////////////////////////`
);

const compiledOZAccount = json.parse(
  fs.readFileSync("./contracts/OZAccount.json").toString("ascii")
);

const accountResponse = await provider.deployContract({
  contract: compiledOZAccount,
  constructorCalldata: [starkKeyPub],
  addressSalt: starkKeyPub,
});
console.log("Account address ", accountResponse.contract_address);

console.log(
  `See account on the explorer: https://goerli.voyager.online/contract/${accountResponse.contract_address}`
);

console.log(
  `Follow the tx status on: https://goerli.voyager.online/tx/${accountResponse.transaction_hash}`
);

console.log(
  `////////////////////////////////////////////////////////////////////////////////
    Waiting for Tx to be Accepted on Starknet - OpenZeppelin Account Deployment...
   ////////////////////////////////////////////////////////////////////////////////`
);

await provider.waitForTransaction(accountResponse.transaction_hash);

console.log("Account contract deployed successfully!"); This operation may require a few minutes to complete, but we can always track its progress via the explorer URL logged on the console. To avoid creating multiple accounts each time we run the command to start the project, be sure to fill out the rest of the code in the project. Fund the new account Before anything else, we must add some code to pause the execution and resume it after all of the above actions are completed. Once launched, this pause is necessary because our function won't stop; we’ll need time to fund our account and confirm the transaction. Hence, we will include the following method in the file. index.js //…

function askQuestion(query) {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  return new Promise((resolve) =>
    rl.question(query, (ans) => {
      rl.close();
      resolve(ans);
    })
  );
}

const ans = await askQuestion(
  "Did you add funds to your Account? Hit enter if yes"
); Note: Before running the program again, be sure to fill out the rest of the code in the project. This will avoid having to fund multiple accounts. After running the code again, we should have a prompt similar to what we have below, pausing the execution while adding some faucets to our account. We need to put some gas in our tank before executing transactions on the StarkNet network (just like we can on Ethereum). Using the official , we can fund our account by pasting the account address from the terminal output. StarkNet Goerli Faucet Once the transaction is approved, hit enter to continue with the rest of the code. Deploy ERC-20 contract We have successfully created a provider, generated private and public key pairs for our Contract-Account interface, deployed account contracts, and funded our account in the previous steps. In this section, we will deploy the ERC-20 contract using the following code snippet. //...

// Use your new account address
const account = new Account(
  provider,
  accountResponse.contract_address,
  starkKeyPair
);

console.log("Reading ERC20 Contract...");

const compiledErc20 = json.parse(
  fs.readFileSync("./contracts/ERC20.json").toString("ascii")
);

// Deploy an ERC20 contract and wait for it to be verified on StarkNet.
console.log(
  `////////////////////////////////////////////////////////////////////////////////
     Deployment Tx - ERC20 Contract to StarkNet...
   ////////////////////////////////////////////////////////////////////////////////`
);

const erc20Response = await provider.deployContract({
  contract: compiledErc20,
});

// Wait for the deployment transaction to be accepted on StarkNet
console.log("Waiting for Tx to be Accepted on Starknet - ERC20 Deployment...");

await provider.waitForTransaction(erc20Response.transaction_hash);

// Get the erc20 contract address
const erc20Address = erc20Response.contract_address;

console.log("ERC20 Address: ", erc20Address);

// Create a new erc20 contract object
const erc20 = new Contract(compiledErc20.abi, erc20Address, provider);

erc20.connect(account); Minting tokens Next, we will mint our tokens utilizing the mint transaction, which will take the account address of the recipient and the number of tokens. Let us implement that functionality using the following code snippet. //...

// Mint 500 tokens to account address
console.log(
  `////////////////////////////////////////////////////////////////////////////////
    Invoke Tx - Minting 500 tokens to ${account.address}...
   ////////////////////////////////////////////////////////////////////////////////`
);

const { transaction_hash: mintTxHash } = await erc20.mint(
  account.address,
  "500",
  {
    // transaction can be rejected if maxFee is lower than actual
    // Error: REJECTED: FEE_TRANSFER_FAILURE
    // Actual fee exceeded max fee.
    maxFee: "999999995330000",
  }
);

// Wait for the invoke transaction to be accepted on StarkNet
console.log(`Waiting for Tx to be Accepted on Starknet - Minting...`);

await provider.waitForTransaction(mintTxHash);

// Check balance - should be 500
console.log(`Calling StarkNet for account balance...`);

const balanceBeforeTransfer = await erc20.balance_of(account.address);

console.log(
  `account Address ${account.address} has a balance of:`,
  number.toBN(balanceBeforeTransfer.res, 16).toString()
); Transfer tokens Now that we have minted tokens let’s transfer some to confirm they exist and are transferable. //...

// Execute transfer of ERC20 tokens
console.log(`Invoke Tx - Transfer 20 tokens back to erc20 contract...`);
const { code, transaction_hash: transferTxHash } = await account.execute(
  {
    contractAddress: erc20Address,
    entrypoint: "transfer",
    calldata: [erc20Address, "20"],
  },
  undefined,
  {
    maxFee: "999999995330000",
  }
);

// Wait for the invoke transaction to be accepted on StarkNet
console.log(
  `////////////////////////////////////////////////////////////////////////////////
    Waiting for Tx to be Accepted on Starknet - Transfer...
   ////////////////////////////////////////////////////////////////////////////////`
);

await provider.waitForTransaction(transferTxHash);

// Check balance after transfer - should be 480
console.log(`Calling StarkNet for account balance...`);
const balanceAfterTransfer = await erc20.balance_of(account.address);

console.log(
  `account Address ${account.address} has a balance of:`,
  number.toBN(balanceAfterTransfer.res, 16).toString()
); In the last section of the code, we check the balance of our account. As you can see from the output, our transactions were successful, and we hold a balance of our tokens. Voila! 🥳 We have minted our first ERC-20 tokens on StarkNet with Infura! To follow up, you can find the entire code for this project on a GitHub repository . here Conclusion In this article, you learned about the StarkNet layer two ZK-rollup, how to access it with Infura RPC endpoints, and how to create and deploy your own ERC-20 tokens on the network. Infura helps bridge the gap for Ethereum developers and facilitates a composable Web3 ecosystem by providing these endpoints. To learn more about StarkNet and how to build on it using Infura, visit the following resources: Resources Infura documentation StarkNet documentation StarkNet.js documentation OpenZeppelin Account Cairo contract documentation Also published . here

A Guide to Infura and StarkNet ZK-Rollup for Ethereum Devs

From Cleopatra in 69 B.C. to Kendall Jenner in 2022 A.D., beauty has since time immemorial captured human attention. However, its standards have changed drastically over time. While earlier, it was all about giving an hourglass body a cosmetic makeover, today, more and more individuals are gravitating toward healthier bodies that glow from the inside out. They are becoming more mindful of what they eat, and how “what they eat” affects or alters their bodies. But, try as much as possible, our busy lifestyle doesn’t always allow us the luxury to prepare wholesome meals. Additionally, work consumes so much of our time that, at the end of the day, we neither have the will nor the energy to innovate & include nourishing diversity on our plates. And this is where we all go horribly wrong! Repetition in food often leads to deficiencies of all kinds, which in turn affects our hair, skin, and nail health in multiple ways. What Are Biotin Gummies and Why Are They Such a Rage? Before we learn about Biotin Gummies, let’s first understand what Biotin is and its potential to improve our skin and hair health. is one of the eight vitamins of the B complex. The word Biotin is derived from the ancient Greek word “biotos,” which means “life” or “sustenance.” B vitamins, particularly biotin, support the health of your skin, hair, eyes, liver, and nervous system. Also known as Vitamin B7, Biotin Biotin deficiency has been observed in people suffering from hair loss or skin rashes on several occasions. As a result, doctors and nutritionists often advise such people to increase their biotin intake. As it is a water-soluble vitamin that flushes itself out of the body when you urinate, its excess doesn’t usually cause any harm to the body. Biotin doses of 30 to 100 micrograms (mcg) per day are commonly suggested for adolescents and adults. To make up for Biotin deficiencies, people often rely on tablets or supplements. However, the problems with biotin pills are: People aren’t comfortable swallowing pills. It’s not something they wish to include in their daily routine. Pills conjure up images of serious sickness. They leave a bad aftertaste. That is why gummies are becoming increasingly popular. Biotin gummies are multivitamins loaded with the right amount of biotin and other essential nutrients that are beneficial for hair, skin, and nails. These Biotin supplements do not come in the shape of capsules or pills that must be swallowed with water, unlike vitamin tablets. Instead, they have a gummy feel that is easy to chew and digest. Natural flavors are added to the good ones, giving them their deliciousness. Taste cannot be overlooked in the rapidly evolving field of healthcare. It must be a top priority, which is why biotin gummies, which come in a variety of flavors, are getting so popular among people of all age groups. The Benefits of Biotin Gummies for Hair, Skin, and Nails: Multivitamin Biotin Gummies for Hair, Skin, and Nails Health! If you are active on Instagram or Facebook, you would have definitely come across numerous brands selling hair, skin, and nail multivitamins. You want to try them, but at the same time, you’re skeptical about their effectiveness. So, here I am, writing this article to show you the many advantages of eating gummies for hair and skin: Reduces Hair Fall & Boosts Hair Growth: Biotin is believed to have a significant effect on hair health. It promotes hair growth by enhancing scalp health. It also helps the body replenish the keratin infrastructure, providing your hair with both thickness and volume. “Low levels of Biotin can cause hair loss, skin rashes, and brittle nails,” says . However, one has to be very cautious about the amount of Biotin they consume. Too much of it can prove harmful to the body. Therefore, one must choose only those hair & skin gummies that contain the right amount of Biotin. Jennifer T. Haley, MD, FAAD Gives Glowing Skin from the Inside: With aging, you feel your skin lacking that nourished look. It appears to be wrinkled and dry. Biotin hair and skin gummies aid in the retention of water, which is vital for healthy-looking skin. Free radicals, which are triggered by stress, junk food, and an unhealthy lifestyle, are another cause of bad skin. Hair and skin gummies enriched with Vitamin C release potent antioxidants that combat free radicals, restoring skin’s lost radiance and beauty. Vitamin E, another crucial nutrient, contains anti-inflammatory qualities that help to repair cells and maintain glowing healthy skin. Deliciousness that Multivitamin Capsules Lack: We have all been there and done that! Embraced ourselves tight, paused breathing, and struggled to gulp down big capsules of water. This is a really unpleasant procedure! However, this is not the case with healthy hair and skin gummies. These vitamins are available in delicious chewable gummy forms that are delectable in taste, easy to chew and leave wonderful flavors on the tongue. How Do I Choose Which Biotin Gummies Are Best for Me? There are so many gummy brands on the market. Everyone calls itself better than the other. Then, how do you decide which skin & hair gummies you can rely on? Which ones to buy! Points to consider when buying vitamin gummies: Prioritize Quality over Price: First off, whenever you are choosing something that directly affects your skin and hair health, do not prioritize cheap over quality. First, ensure the quality is good and only then think about the money! It is never a good idea to compromise on health for money. Instead of investing your money in 3 different kinds of multivitamin gummies, one for hair, one for skin, and one for nails, buy the kind that impacts all 3 at once. For example, the What’s Up Beauty Gummies! Multivitamin Gummies that impact both skin & hair: Enriched with 13 essential nutrients, including superfoods such as Aloe Vera, Sea Buckthorn, and Grape Seed Extract, these by What’s Up Wellness work equally on improving hair, skin, and nail health. What’s Up Wellness is a young & promising startup striving to make wellness fun & easy for people. biotin gummies As mentioned above in the blog, so many times multivitamin gummies for hair and skin promise to give positive results. However, if you look at the contents list closely, you’ll notice that some of these gummies include more Biotin and other compounds than is suggested by the doctors. Ensure that the ones you purchase have all these components under medical limits. Carefully check the ingredients: Gummies are sold by a variety of companies on the internet. However, a doctor’s authority is the finest way to discern a trustworthy brand from one that isn’t. When seeking hair and skin multivitamin supplements, a doctor’s advice is required. Additionally, search for certifications of approval from your local or national food safety and control agencies. Look for Doctor & Food Authority’s Approval: Conclusion: There are a lot of other things to think about while buying multivitamin gummies. Look for gummies that have been recommended by doctors and approved by the national food safety and control organization in your country. Remember, although delicious, biotin gummies aren’t magical pills that will transform your hair and skin instantly. No matter what, you would have to improve your lifestyle, exercise regularly, and eat well to experience good health.

3 Surprising Benefits of Biotin Gummies

3 beneficios sorprendentes de las gomitas de biotina

Saving Democracy - With TV AI Realtime Fact-checking

Real-time face recognition systems remain a very popular topic in computer vision, and a large number of companies have developed their own solutions to try and tap into the growing market. Compared with traditional methods of recognition, real-time face recognition systems have the advantage of using multiple instances of the same individual in sequential frames. If you’re looking to take advantage of the benefits of real-time face recognition, open-source projects can be a great starting point. Since the source code is published, you can see how it works and be sure that it doesn’t steal your data. In this article, we will help you navigate through the best open-source face recognition projects and show you why choosing open-source software is often the best option. Introduction to Open-Source Face Recognition Solutions Face recognition systems vary in terms of their functionality and unique features. But generally, the process of automating your system with face recognition software requires the same basic steps. First, you place a camera in your desired location and start streaming video. The camera should be placed in such a way that the lens gets enough light and the subject will be looking at the camera. If getting a complete look at the user’s face is not possible, the camera should have as clear a resolution as possible. In order to not overload the face recognition server, it's better to detect motion first. Why Choose an Open-Source Face Recognition Project? Open-source software has a lot of advantages. First of all, with open-source code, you’re sure about how your data is treated. Secondly, open-source projects are often of higher quality. Bugs are identified very quickly, as the code is being constantly reviewed by multiple developers. Thirdly, licence fees are lower, and such projects are usually developed in-house or by freely choosable IT service providers. It’s hard to find outdated open-source software, as it usually follows modern software development practices. Finally, open-source is considered to be the next level of code maturation. It allows developers to understand a code fluently in a few minutes and inspires them to work on it. Best Open-Source Face Recognition Software We studied github repositories of real-time open-source face recognition software and prepared a list of the best options: 1. Deepface This library supports different face recognition methods like FaceNet and InsightFace. It also provides a REST API, but it only supports verification methods, so you can’t create face collections and find a face among them. Even though it’s easy to start if you are a Python developer, it may be harder for others to integrate. The latest version as of the beginning of 2021 is 0.0.49. 2. CompreFace This solution was only published on in July 2020 and looks very promising. CompreFace made our best open-source face recognition projects’ list because it’s one of the few self-hosted REST API face recognition solutions that can be started with one docker-compose command. A REST API allows you to easily integrate it into your system without prior machine learning skills. Additionally, it’s scalable, so you can simultaneously recognize faces on several video streams. github CompreFace has a simple UI for managing user roles and face collections. It gives a choice between the two most popular face recognition methods: FaceNet (LFW accuracy 99.65%) and InsightFace (LFW accuracy 99.86%). It’s still in the active development phase, and the latest version as of the beginning of 2021 is version 0.5. 3. Face Recognition The main feature of this solution is that it uses their Python API and binary command line tool. Additionally, installation instructions to all main platforms and even a docker image for a fast setup are available on their github. Despite its popularity, the software has a few disadvantages. The last release was in 2018, and there have been no major improvements since then. It uses a fairly outdated face recognition model with only 99.38% accuracy on LFW and doesn’t have a REST API. 4. InsightFace InsightFace is another open-source Python library that uses one of the most recent and accurate face recognition methods for face detection ( ) and face recognition ( ). The accuracy of this solution is very high – 99.86% on the LFW dataset. The only disadvantage is that it’s not easy to use. RetinaFace SubCenter-ArcFace 5. FaceNet FaceNet is a popular open-source Python library. The accuracy of this method is quite high – 99.65% on the LFW dataset, which is great but not the highest. The disadvantages of this solution are that it doesn't have a REST API and that the repository is no longer supported (the last update was in April 2018). 6. InsightFace-REST This is another promising repository created in 2019 with active development starting in October 2020. Like CompreFace, this is a docker-based solution that provides a convenient REST API. The biggest advantage is that its developers sped up InsightFace’s recognition by a factor of three. The disadvantage of this solution is that it provides only embeddings of the face and doesn't give an API for actual face recognition, so you’ll need to have your own classifier. The repository still doesn’t have a license, so you’ll need to ask the author if you can use it. The latest version as of the beginning of 2021 is v0.5.9.6. Conclusion While the best open-source face recognition projects available on GitHub today are different in their features, they all have a potential to make your life easier. When choosing an open-source face recognition solution, we recommend compiling a list of criteria that are relevant to your business and choosing the option that prioritizes the same things you do. While there may be some features that are more important to you than others, each of the free open-source projects we’ve identified here will provide a high-quality real-time face recognition experience.

6 Best Open-Source Projects for Real-Time Face Recognition

Los 6 mejores proyectos de código abierto para el reconocimiento facial en tiempo real

transformer-based language model definitely lives up to the hype. Following the natural evolution of , this generative language model drew a lot of attention by and appearing in the online text adventure game . OpenAI’s GPT-2 Artificial Intelligence (AI) engaging in interviews AI Dungeon GPT-2, built on transformer decoder blocks, essentially leverages its to train and formulate word sequences based on what it has already learned. Its ability to adapt and generate human-like text interactions with minimal prompts quickly is exceptional. natural language prediction algorithm So it’s no surprise that it’s been deployed across applications like chatbots (of course), translation platforms, (which shows its impressive cognitive abilities), , , and more. TL;DR generators music generators poetry generators Although more complex Natural Language Processing (NLP) models like and were released recently, GPT-2 continues to reign supreme. One of the primary reasons for this is its ability to run efficiently on everyday hardware. For example, the sheer number of trainable parameters, 1.5 billion to be exact, only demands 6.5 GB storage. GPT-3 Google T5 So at , we decided to put it to the test and see what else we could train it to do. Someone suggested playing a game of chess, and we ran with it. Intersog Machine Learning (ML) researcher already trained . The model is clear evidence of its ability to recognize known patterns within the game. Shawn Presser GPT-2 to play chess using Portable Game Notation (PGN) files We decided to take it a step further by training the GPT-2 model on the current board state rather than PGN sequences. This approach ensures that it can play the game based on the present without going through gaming history to predict the next best move. The code you’ll see in the steps below is inspired by and trained on . Professor Blank’s Programming a Chess Player Presser’s Cryochess – GPT-2 1.5B chess engine Step 1. Set up Your Dependencies To play chess with smart algorithms, you need a powerful ML-ready machine with a robust Graphics Processing Unit (GPU). Install , , and . It’s best to engage in this activity in a with a installed. CUDA 10.1 PyTorch TensorFlow 2 virtual environment JupyterLab extension Install python-chess [4] and aitextgen [5] modules: In [ ]: !pip install python-chess !pip install aitextgen !pip install tqdm Download PGN files to the PGN folder. You also have the option of converting databases (*.sg4) to PGN format. For this exercise, we engaged in training by leveraging 100,000 games in PGN archives. SCID Some valuable PGN resources include the following: PGN ChessBook PGN Mentor The Week in Chess import os if not os.path.exists("pgn"): os.mkdir("pgn") 2. Generate Training Data As reflected in the example below, our model uses the current board state along with the training file for the next move on each line. It follows the following format: [Result] FEN-position-and-side-only - next_move [1-0] r1bq3k/ppp2rpp/5b2/3n4/3P4/P4p2/BP1B1PPP/R2QR1K1 w - a2d5 [1-0] 2bQ4/p4kb1/6n1/q1p1p3/1rn1P3/N3BP2/1PP5/2KR2R1 w - a3c4 [0-1] 1r3rk1/p4nbp/1qppb1p1/4p3/PP2P3/4NN1P/2QB1PP1/2R1R1K1 b - f8c8 We decided to use only chess matches that were won and skipped draws. The code to generate this function is as follows: import os from tqdm.auto import tqdm import glob import chess.pgn MAX_IMPORT = 100000 def importPgn(filename, s, max_import): counter = 0 total = 0 with open(filename) as f: for line in f: if "[Result" in line: total += 1 if total > max_import: total = max_import pbar = tqdm(total=total, desc="read " + filename, unit=" games", mininterval=1) pgn = open(filename) while counter < max_import: game = chess.pgn.read_game(pgn) if not game: break board = game.board() moves = game.mainline_moves() count = sum(1 for _ in moves) # skip unfinished games if count <= 5: continue result = game.headers["Result"] # import only resultative games if result != "1-0" and result != "0-1": continue for move in moves: if board.turn == chess.WHITE and result == "1-0": line = ( "[1-0] " + " ".join(board.fen().split(" ", 2)[:2]) + " - " + move.uci() ).strip() s.add(line) elif board.turn == chess.BLACK and result == "0-1": line = ( "[0-1] " + " ".join(board.fen().split(" ", 2)[:2]) + " - " + move.uci() ).strip() s.add(line) board.push(move) counter += 1 pbar.update(1) pbar.close() return counter def convert(): games = 0 moves = 0 max_import = MAX_IMPORT s = set() # load previous state if os.path.exists("fen.txt"): with open("fen.txt") as f: for line in tqdm(f, desc="read fen.txt", unit=" moves", mininterval=1): if line: s.add(line) max_import -= 1 if max_import <= 0: break for file in glob.glob("pgn/*.pgn"): count = importPgn(file, s, max_import) games += count max_import -= count if max_import <= 0: break with open("fen.txt", "w") as f: for line in tqdm(s, desc="write fen.txt", unit=" moves", mininterval=1): f.write(line + "\n") moves += 1 print("imported " + str(games) + " games, " + str(moves) + " moves") convert() It took us about 15 minutes to import 100,000 games. If you want to use more games for training, you’ll also need more RAM. Step 4: Training the GPT-2 Model As described in the , we trained a small GPT-2 model from scratch using only the model memory. We chose a small model as we could quickly train it on basic/average hardware (rather than larger models). aitextgen documentation Larger models come with their own sets of demands and benefits, but it’s far too complex for a simple demonstration. The training function can run many times, repeat it, and archive acceptable loss as a model checkpoint. As model checkpoints are periodically saved, the training function can be run multiple times, repeat the training, and achieve acceptable losses. In this scenario, to save time, we stopped at a loss value close to 0.8. Even at this level, the GPT-2 model could predict moves with an acceptable level of accuracy. To better fit with your GPU and negate out of memory scenarios, tune-up batch_size, and num_workers. from aitextgen import aitextgen from aitextgen.utils import build_gpt2_config from aitextgen.TokenDataset import TokenDataset from aitextgen.tokenizers import train_tokenizer import os file_name = "fen.txt" model_dir = "trained_model" config_file = os.path.join(model_dir, "config.json") pytorch_model_file = os.path.join(model_dir, "pytorch_model.bin") vocab_file = os.path.join(model_dir, "aitextgen-vocab.json") merges_file = os.path.join(model_dir, "aitextgen-merges.txt") dataset_cache_file = os.path.join(model_dir, "dataset_cache.tar.gz") max_length = 100 vocab_size = 10000 def train(): if not os.path.exists(model_dir): os.mkdir(model_dir) # train tokenizer if necessary if not os.path.exists(vocab_file): print("training tokenizer, please wait...") train_tokenizer(file_name, save_path=model_dir, vocab_size=vocab_size) if os.path.exists(dataset_cache_file): # use cache data = TokenDataset(dataset_cache_file,vocab_file=vocab_file,merges_file=merges_file,block_size=max_length,from_cache=True,) else: # or create token cache if necessary data = TokenDataset(file_name,vocab_file=vocab_file,merges_file=merges_file,block_size=max_length,line_by_line=True,save_cache=True,cache_destination=dataset_cache_file) if not os.path.exists(pytorch_model_file): config = build_gpt2_config(vocab_size=vocab_size,max_length=max_length,dropout=0.0,n_embd=512,n_head=16,n_layer=16,) ai = aitextgen(config=config, vocab_file=vocab_file, merges_file=merges_file, to_gpu=True) else: ai = aitextgen(model=pytorch_model_file, config=config_file, vocab_file=vocab_file, merges_file=merges_file, to_gpu=True) ai.train(data, num_steps=150000, generate_every=1000, save_every=1000, learning_rate=1e-4, batch_size=16, num_workers=4,) train() This process takes about eight hours. However, if you want to use a well-trained model, it’s best to give it a few days. Step 5: Assessment 5.1. Introduce a Random Player (random_player) In this scenario, a random player is a simple (or novice) player who’s pretty poor at the game of chess. The function basically makes an arbitrary choice based on a list of valid moves. import random def random_player(board): move = random.choice(list(board.legal_moves)) return move.uci(), False, False 5.2. Introduce a GPT-2 Player (gpt2_player) This player uses AI-powered GPT-2 to predict the next move. The model prompt is constructed from the expected result from the current board state and side (and since we want to win, white = 1-0 and black = 0-1). From here, once prompted the model supplements the next generated move. The GPT-2 player is trained on a small ML dataset and can never evolve into a chess master. The predicted moves are based on unknown board states and not ones presented during the training phase. Whenever the model generates an invalid movement, it’s fixed by using a random valid move. import os from aitextgen import aitextgen from aitextgen.utils import build_gpt2_config import chess from tqdm.auto import tqdm model_dir = "trained_model" vocab_file = "aitextgen-vocab.json" merges_file = "aitextgen-merges.txt" max_length = 100 model_dir = "trained_model" config_file = os.path.join(model_dir, "config.json") pytorch_model_file = os.path.join(model_dir, "pytorch_model.bin") vocab_file = os.path.join(model_dir, "aitextgen-vocab.json") merges_file = os.path.join(model_dir, "aitextgen-merges.txt") dataset_cache_file = os.path.join(model_dir, "dataset_cache.tar.gz") max_length = 100 ai = aitextgen( model=pytorch_model_file, config=config_file, vocab_file=vocab_file, merges_file=merges_file, from_cache=True, to_gpu=True, # to_fp16=True ) # a set to find known states db = set() with open("fen.txt") as f: for line in tqdm(f, desc="read fen.txt", unit=" moves"): if line: db.add(" ".join(line.split(" ", 3)[:3])) def gpt2_player(board): if board.turn == chess.WHITE: prompt = "[1-0] " + " ".join(board.fen().split(" ", 2)[:2]) else: prompt = "[0-1] " + " ".join(board.fen().split(" ", 2)[:2]) isKnown = prompt in db prediction = ai.generate_one(prompt=prompt,max_length=max_length,temperature=0.9,top_k=0,) isPredicted = False try: uci = prediction.split(' - ')[1].strip() move = chess.Move.from_uci(uci) isPredicted = True except Exception as e: # print(str(e)) move = None if not move or move not in board.legal_moves: # give up and do random move move = random.choice(list(board.legal_moves)) isPredicted = False return move.uci(), isPredicted, isKnown Step 6: Play a Game of Chess Now comes the fun part! This function demands two players to play chess against each other: import time from IPython.display import display, HTML, clear_output import chess def who(player): return "White" if player == chess.WHITE else "Black" def display_board(board, use_svg): if use_svg: return board._repr_svg_() else: return "<pre>" + str(board) + "</pre>" def play_game(player1, player2, visual="svg", pause=0.1): """ playerN1, player2: functions that takes board, return uci move visual: "simple" | "svg" | None """ use_svg = (visual == "svg") board = chess.Board() known1 = 0 predicted1 = 0 total1 = 0 known2 = 0 predicted2 = 0 total2 = 0 if visual is not None: display(display_board(board, visual == 'svg')) try: while not board.is_game_over(claim_draw=True): if board.turn == chess.WHITE: uci, isPredicted, isKnown = player1(board) total1 += 1 if isKnown: known1 += 1 if isPredicted: predicted1 += 1 else: uci, isPredicted, isKnown = player2(board) total2 += 1 if isKnown: known2 += 1 if isPredicted: predicted2 += 1 name = who(board.turn) board.push_uci(uci) board_stop = display_board(board, use_svg) html = "<b>Move %s %s, Play '%s':</b><br/>%s<br/>Known/Predicted/Total moves: %s/%s/%s %s%% - %s/%s/%s %s%%" % ( len(board.move_stack), name, uci, board_stop, known1, predicted1, total1, round(predicted1 / (total1 or 1) * 100), known2, predicted2, total2, round(predicted2 / (total2 or 1) * 100)) if visual is not None: if visual == "svg": clear_output(wait=True) display(HTML(html)) if visual == "svg": time.sleep(pause) except KeyboardInterrupt: msg = "Game interrupted!" return (None, msg, board) result = "1/2-1/2" if board.is_checkmate(): msg = "checkmate: " + who(not board.turn) + " wins!" result = "1-0" if who(not board.turn) == "White" else "0-1" elif board.is_stalemate(): msg = "draw: stalemate" elif board.is_fivefold_repetition(): msg = "draw: 5-fold repetition" elif board.is_insufficient_material(): msg = "draw: insufficient material" elif board.can_claim_draw(): msg = "draw: claim" if visual is not None: print(msg) return (result, msg, board) Let’s play the gpt2_player vs. random_player: play_game(gpt2_player, random_player) pass Move 61 White, Play 'd2d7': Known/Predicted/Total moves: 2/29/31 94% - 0/0/30 0% checkmate: White wins! When you're working with a small dataset, these chess matches often end up in a stalemate. While we aren't a hundred percent certain, it could also result from not analyzing the next move and choosing the best one. Now let's play 100 games where the gpt2_player plays white: from tqdm.auto import tqdm plays = 100 white_wins = 0 black_wins = 0 pbar1 = None pbar2 = None for i in tqdm(range(plays), desc="Plays"): if not pbar1: pbar1 = tqdm(total=plays, desc="White wins") if not pbar2: pbar2 = tqdm(total=plays, desc="Black wins") result, _, _ = play_game(gpt2_player, random_player, visual=None) if result is None: break elif result == "1-0": white_wins += 1 pbar1.update(1) elif result == "0-1": black_wins += 1 pbar2.update(1) pbar1.close() pbar2.close() print("Final score: %s-%s" % (white_wins, black_wins)) Final score: 52-0 Most often, the GPT-2 controlled player wins the game or draws. In this scenario, the GPT-2 controlled white player won more than half the games. We also noticed that the current board state was almost always new to the model. The model was also able to engage in more valid moves than fails. So we can conclude that the GPT-2 model was able to learn some basic patterns from the training data to predict the next move successfully. Let’s play the gpt2_player vs. Human Player: The following function effectively handles human input into the game: def human_player(board): uci = get_move("%s's move [q to quit]> " % who(board.turn)) legal_uci_moves = [move.uci() for move in board.legal_moves] while uci not in legal_uci_moves: print("Legal moves: " + (",".join(sorted(legal_uci_moves)))) uci = get_move("%s's move[q to quit]> " % who(board.turn)) return uci, True, False def get_move(prompt): uci = input(prompt) if uci and uci[0] == "q": raise KeyboardInterrupt() try: chess.Move.from_uci(uci) except: uci = None return uci Do you want to play against gpt2_player? If you do, note that you must enter your move in the user-computer interface representing each piece and place. This means that typing something like "a2a4"moves the piece located at a2 to a4. play_game(human_player, gpt2_player) pass Move 10 Black, Play 'b7b6': Known/Predicted/Total moves: 0/5/5 100% - 2/5/5 100% Conclusion In this experiment, we deployed GPT-2 to learn and play a game of chess. Although it was nowhere near our grandmasters (at least not yet), it showed that it was capable of understanding the game's basics. With more training data and larger model size, the model can theoretically take it to the next level and possibly beat human players. An interesting observation was that the model itself behaved quite erratically when playing the random player who made arbitrary moves. However, when we added a human player, the model made more calculated and confident moves. This suggests that a better player creates board states that are similar to the training data. We also noticed that the GPT-2 model engaged in natural text generation and confidently generated different types of textual patterns. It was also able to leverage its training data to successfully handle unknown input, almost like it developed a new internal algorithm. If you like to do your own experiments, this notebook is available . HERE

How to Play Chess Using a GPT-2 Model

Special thanks to Eli Ben-Sasson for ongoing help and explanations, and Justin Drake for reviewing In the last part of this series, we talked about how you can make some pretty interesting succinct proofs of computation, such as proving that you have computed the millionth Fibonacci number, using a technique involving polynomial composition and division. However, it rested on one critical ingredient: the ability to prove that at least the great majority of a given large set of points are on the same low-degree polynomial. This problem, called “low-degree testing”, is perhaps the single most complex part of the protocol. We’ll start off by once again re-stating the problem. Suppose that you have a set of points, and you claim that they are all on the same polynomial, with degree less than D (ie. deg < 2 means they’re on the same line, deg < 3 means they’re on the same line or parabola, etc). You want to create a succinct probabilistic proof that this is actually true. tooltip Left: points all on the same deg < 3 polynomial. Right: points not on the same deg < 3 polynomial If you want to verify that the points are on the same degree < D polynomial, you would have to actually check every point, as if you fail to check even one point there is always some chance that that point will not be on the polynomial even if all the others are. But what you do is that at least (eg. 90%) of all the points are on the same polynomial. all can probabilistically check some fraction tooltip tooltip Top: possibly close enough to a polynomial. Bottom: not close enough to a polynomial. Bottom left: somewhat close to two polynomials, but not close enough to either one. Bottom right: definitely not close enough to a polynomial. If you have the ability to look at point on the polynomial, then the problem is easy. But what if you can only look at a few points - that is, you can ask for whatever specific point you want, and the prover is obligated to give you the data for that point as part of the protocol, but the total number of queries is limited? Then the question becomes, how many points do you need to check to be able to tell with some given degree of certainty? every Clearly, D points is enough. D points are exactly what you need to uniquely define a degree < D polynomial, so set of points that you receive will correspond to degree < D polynomial. As we see in the figure above, however, D+1 points or more give some indication. not any some do The algorithm to check if a given set of values is on the same degree < D polynomial with D+1 queries is not too complex. First, select a random subset of D points, and use something like Lagrange interpolation (search for “Lagrange interpolation” for a more detailed description) to recover the unique degree < D polynomial that passes through all of them. Then, randomly sample one more point, and check that it is on the same polynomial. here tooltip Note that this is only a proximity test, because there’s always the possibility that most points are on the same low-degree polynomial, but a few are not, and the D+1 sample missed those points entirely. However, we can derive the result that if less than 90% of the points are on the same degree < D polynomial, then the test will fail with high probability. Specifically, if you make D+k queries, and if at least some portion p of the points are not on the same polynomial as the rest of the points, then the test will only pass with probability (1 - p)k. But what if, as in the examples from the previous article, D is very high, and you want to verify a polynomial’s degree with less than D queries? This is, of course, impossible to do directly, because of the simple argument made above (namely, that k <= D points are all on at least one degree < D polynomial). However, it’s quite possible to do this indirectly , and achieve massive efficiency gains by doing so. And this is exactly what new protocols like (“Fast RS IOPP”, RS = “ ”, IOPP = “Interactive Oracle Proofs of Proximity”), and similar earlier designs called probabilistically checkable proofs of proximity (PCPPs), try to achieve. any by providing auxiliary data FRI Reed-Solomon A First Look at Sublinearity To prove that this is at all possible, we’ll start off with a relatively simple protocol, with fairly poor tradeoffs, but that still achieves the goal of sublinear verification complexity - that is, you can prove proximity to a degree < D polynomial with less than D queries (and, for that matter, less than O(D) computation to verify the proof). The idea is as follows. Suppose there are N points (we’ll say N = 1 billion), and they are all on a degree < 1,000,000 polynomial f(x). We find a bivariate polynomial (ie. an expression like 1 + x + xy + x^5*y^3 + x^12 + x*y^11), which we will denote g(x, y), such that g(x, x^1000) = f(x). This can be done as follows: for the kth degree term in f(x) (eg. 1744 * x^185423), we decompose it into x^(k % 1000) * y^floor(k / 1000) (in this case, 1744 * x^423 * y^185). You can see that if y = x^1000, then 1744 * x^423 * y^185 equals 1744 * x^185423. In the first stage of the proof, the prover commits to (ie. makes a Merkle tree of) the evaluation of g(x, y) over the square [1..N] x {x^1000: 1 <= x <= N} - that is, all 1 billion x coordinates for the columns, and all 1 billion corresponding for the y coordinates of the rows. The diagonal of the square represents the values of g(x, y) that are of the form g(x, x^1000), and thus correspond to values of f(x). entire thousandth powers The verifier then randomly picks perhaps a few dozen rows and columns (possibly using if we want a non-interactive proof), and for each row or column that it picks the verifier asks for a sample of, say, 1010 points on the row and column, making sure in each case that one of the points demanded is on the diagonal. The prover must reply back with those points, along with Merkle branches proving that they are part of the original data committed to by the prover. The verifier checks that the Merkle branches match up, and that the points that the prover provides actually do correspond to a degree-1000 polynomial. the Merkle root of the square as a source of pseudorandomness tooltip This gives the verifier a statistical proof that (i) most rows are populated mostly by points on degree < 1000 polynomials, (ii) most columns are populated mostly by points on degree < 1000 polynomials, and (iii) the diagonal line is mostly on these polynomials. This thus convinces the verifier that most points on the diagonal actually do correspond to a degree < 1,000,000 polynomial. If we pick thirty rows and thirty columns, the verifier needs to access a total of 1010 points * 60 rows+cols = 60600 points, less than the original 1,000,000, but not by that much. As far as computation time goes, interpolating the degree < 1000 polynomials will have its own overhead, though since polynomial interpolation can be made subquadratic the algorithm as a whole is still sublinear to verify. The complexity is higher: the prover needs to calculate and commit to the entire N * N rectangle, which is a total of 1018 computational effort (actually a bit more because polynomial evaluation is still superlinear). In all of these algorithms, it will be the case that proving a computation is substantially more complex than just running it; but as we will see the overhead does not have to be high. prover that A Modular Math Interlude Before we go into our more complex protocols, we will need to take a bit of a digression into the world of modular arithmetic. Usually, when we work with algebraic expressions and polynomials, we are working with regular numbers, and the arithmetic, using the operators +, -, *, / (and exponentiation, which is just repeated multiplication), is done in the usual way that we have all been taught since school: 2 + 2 = 4, 72 / 5 = 14.4, 1001 * 1001 = 1002001, etc. However, what mathematicians have realized is that these ways of defining addition, multiplication, subtraction and division are not the self-consistent ways of defining those operators. only The simplest example of an alternate way to define these operators is modular arithmetic, defined as follows. The % operator means “take the remainder of”: 15 % 7 = 1, 53 % 10 = 3, etc (note that the answer is always non-negative, so for example -1 % 10 = 9). For any specific prime number p, we can redefine: The above rules are all self-consistent. For example, if p = 7, then: 5 + 3 = 1 (as 8 % 7 = 1)1 - 3 = 5 (as -2 % 7 = 5)2 * 5 = 33 / 5 = 2 (as (3 * 55) % 7 = 9375 % 7 = 2) More complex identities such as the distributive law also hold: (2 + 4) * 3 and 2 * 3 + 4 * 3 both evaluate to 4. Even formulas like (a2 - b2) = (a - b) * (a + b) are still true in this new kind of arithmetic. Division is the hardest part; we can’t use regular division because we want the values to always remain integers, and regular division often gives non-integer results (as in the case of 3 / 5). The funny p-2 exponent in the division formula above is a consequence of getting around this problem using , which states that for any nonzero x < p, it holds that xp-1 % p = 1. This implies that xp-2 gives a number which, if multiplied by x one more time, gives 1, and so we can say that xp-2 (which is an integer) equals 1 / x. A somewhat more complicated but faster way to evaluate this modular division operator is the , implemented in python . Fermat’s little theorem extended Euclidean algorithm here tooltip Because of how the numbers "wrap around", modular arithmetic is sometimes called "clock math" With modular math we’ve created an entirely new system of arithmetic, and because it’s self-consistent in all the same ways traditional arithmetic is self-consistent we can talk about all of the same kinds of structures over this field, including polynomials, that we talk about in “regular math”. Cryptographers love working in modular math (or, more generally, “finite fields”) because there is a bound on the size of a number that can arise as a result of any modular math calculation - no matter what you do, the values will not “escape” the set {0, 1, 2 ... p-1}. Fermat’s little theorem also has another interesting consequence. If p-1 is a multiple of some number k, then the function x -> xk has a small “image” - that is, the function can only give (p-1)/k + 1possible results. For example, x -> x2 with p=17 has only 9 possible results. tooltip With higher exponents the results are more striking: for example, x -> x8 with p=17 has only 3 possible results. And of course, x -> x16 with p=17 has only 2 possible results: for 0 it returns 0, and for everything else it returns 1. Now A Bit More Efficiency Let us now move on to a slightly more complicated version of the protocol, which has the modest goal of reducing the prover complexity from 1018 to 1015, and then 109. First, instead of operating over regular numbers, we are going to be checking proximity to polynomials . As we saw in the previous article, we need to do this to prevent numbers in our STARKs from growing to 200,000 digits anyway. Here, however, we are going to use the “small image” property of certain modular exponentiations as a side effect to make our protocols far more efficient. as evaluated with modular math Specifically, we will work with p = 1,000,005,001. We pick this modulus because (i) it’s greater than 1 billion, and we need it to be at least 1 billion so we can check 1 billion points, (ii) it’s prime, and (iii) p-1 is an even multiple of 1000. The exponentiation x1000 will have an image of size 1,000,006 - that is, the exponentiation can only give 1,000,006 possible results. This means that the “diagonal” (x, x1000) now becomes a diagonal with a wraparound; as x1000 can only take on 1,000,006 possible values, we only need 1,000,006 rows. And so, the full evaluation of g(x, x1000) now has only ~1015 elements. tooltip As it turns out, we can go further: we can have the prover only commit to the evaluation of g on a single column. The key trick is that the original data itself already contains 1000 points that are on any given row, so we can simply sample those, derive the degree < 1000 polynomial that they are on, and then check that the corresponding point on the column is on the same polynomial. We then check that the column itself is a < 1000 polynomial. tooltip The verifier complexity is still sublinear, but the prover complexity has now decreased to 109, making it linear in the number of queries (though it’s still superlinear in practice because of polynomial evaluation overhead). And Even More Efficiency The prover complexity is now basically as low as it can be. But we can still knock the verifier complexity down further, from quadratic to logarithmic. And the way we do is by making the algorithm recursive. We start off with the last protocol above, but instead of trying to embed a polynomial into a 2D polynomial where the degrees in x and y are equal, we embed the polynomial into a 2D polynomial where the degree bound in x is a small constant value; for simplicity, we can even say this must be 2. That is, we express f(x) = g(x, x^2), so that the row check always requires only checking 3 points on each row that we sample (2 from the diagonal plus one from the column). that If the original polynomial has degree < n, then the rows have degree < 2 (ie. the rows are straight lines), and the column has degree < n/2. Hence, what we now have is a linear-time process for converting a problem of proving proximity to a polynomial of degree < n into a problem of proving proximity to a polynomial of degree < n/2. Furthermore, the number of points that need to be committed to, and thus the prover’s computational complexity, goes down by a factor of 2 each time (Eli Ben-Sasson likes to compare this aspect of FRI to , with the key difference that unlike with FFTs, each step of recursion only introduces one new sub-problem instead of branching out into two). Hence, we can simply keep using the protocol on the column created in the previous round of the protocol, until the column becomes so small that we can simply check it directly; the total complexity is something like n + n/2 + n/4 + … ~= 2n. fast fourier transforms tooltip In reality, the protocol will need to be repeated several times, because there is still a significant probability that an attacker will cheat round of the protocol. However, even still the proofs are not too large; the verification complexity is logarithmic in the degree, though it goes up to log2(n) if you count the size of the Merkle proofs. one The “real” FRI protocol also has some other modifications; for example, it uses a binary (another weird kind of finite field; basically, the same thing as the 12th degree extension fields I talk about , but with the prime modulus being 2). The exponent used for the row is also typically 4 and not 2. These modifications increase efficiency and make the system friendlier to building STARKs on top of it. However, these modifications are not essential to understanding how the algorithm works, and if you really wanted to, you could definitely make STARKs with the simple modular math-based FRI described here too. Galois field here Soundness I will warn that - that is, determining just how low the probability is that an optimally generated fake proof will pass the test for a given number of checks - is still somewhat of a “here be dragons” area in this space. For the simple test where you take 1,000,000 + k points, there is a simple lower bound: if a given dataset has the property that, for any polynomial, at least portion p of the dataset is not on the polynomial, then a test on that dataset will pass with at most (1-p)k probability. However, even that is a very pessimistic lower bound - for example, it’s not possible to be much more than 50% close to low-degree polynomials at the same time, and the probability that the first points you select will be the one with the most points on it is quite low. For full-blown FRI, there are also complexities involving various specific kinds of attacks. calculating soundness two is a recent article by Ben-Sasson et al describing soundness properties of FRI in the context of the entire STARK scheme. In general, the “good news” is that it seems likely that in order to pass the D(x) * Z(x) = C(P(x)) check on the STARK, the D(x) values for an invalid solution would need to be “worst case” in a certain sense - they would need to be maximally far from valid polynomial. This implies that we don’t need to check for much proximity. There are proven lower bounds, but these bounds would imply that an actual STARK need to be ~1-3 megabytes in size; conjectured but not proven stronger bounds reduce the required number of checks by a factor of 4. Here any that The third part of this series will deal with the last major part of the challenge in building STARKs: how we actually construct constraint checking polynomials so that we can prove statements about arbitrary computation, and not just a few Fibonacci numbers. All content written by me is by default released freely under the . WTFPL

STARKs, Part II: Thank Goodness It's FRI-day

Machines That Play (Post Deep Blue)

A Tale of Memory, User Experience, and Fractals Screen shot of applying Perlin noise to Grasp Theory memory island terrain. Remembering… I have been building a personal ( ) called . I use it to ingest all the books I read or listen to so that I can quickly organize and recall that information. content management system CMS Grasp Theory The goal of the CMS is to provide the best experience for integrating information, synthesizing new information, and recalling information. While researching effective techniques for consuming and remembering information, I came across the concept of the “ ”. memory palace Perhaps, you have heard about the concept of a memory palace from in or in his book . It’s a powerful tool and is used by memorization professionals to do incredible things like . Joshua Foer his TED talk Moonwalking With Einstein memorize 70,000 digits of PI https://en.chessbase.com/post/memory-techniques-memory-palace-from-roman-times-to-today The memory palace technique involves visualizing a familiar 3D space and then mentally placing objects you wish to remember along a path within it. Because of our brain’s remarkable spatial encoding abilities, the technique makes recalling objects along a path within a memory palace trivial. Your own house is the colloquial example. You can easily navigate mentally from outside to inside, from room to room, and from piece of furniture to piece of furniture in each room. Your house provides enough distinction so there is a memorable relationship between rooms and enough hierarchy to help the mind transition between rooms and sections of rooms. Could the memory palace technique be used to do more than memorize long lists of numbers? Could it be leveraged to recall general knowledge stored in a CMS? Building Memory Island A content management system needs to scale as more content is added. Likewise, the memory palace implementation would need to scale as well. Ideally, it would have one memory palace for each topic that warranted deep exploration. This meant it would need to support many memory palaces. The CMS should also make it easy to remember all memory palaces and where they are in relation to each other. Essentially, there needed to be a memory palace for the memory palaces! Storing buildings inside of buildings might be confusing so I decided that I wanted to bask in the sun on my own personal island. On the island, I could build and organize many memory palaces with a Piña Colada in hand. https://www.3d-relief.com/Raised-relief-maps--of-the-world/Reliefkarten-USA/raised-relief-map-hawai.html?language=en The island needed to function just like a single memory palace. It needed enough detail at different levels of scale to accommodate forming groups of memory palaces and perhaps even forming groups of groups. Additionally, it needed enough interesting features to help orient someone at different scales the same way it is easy to maintain orientation in your own house. If successful, I should easily be able to recall every memory palace I had placed on the island. The question became, “How do you make the terrain of an island interesting?” How do you make mountains memorable? On the First Day, There Were Fuzzies. It Was Good. I wanted the elevation profile of the island to help enhance recall of all the memory palaces that were placed on it. I also didn’t want to draw the elevation profile manually so I wanted to generate it . procedurally If I could generate it procedurally, I could supply a few variables to some code and have it spit out the elevation profile for my island. This would allow me to iterate quickly as I tested the effects of different values for the variables. The combination of global randomness and local predictability is powerful. Those already familiar with procedural generation know about Ken Perlin’s invention, the Perlin noise function ( ). and it’s more performant simplex predecessor The Perlin noise function generates unique but “locally predictable” outputs. This gives a nice balance of high level randomness with low level continuous predictability. This combination of randomness and local continuity is so powerful that even . Minecraft uses it to generate it’s terrain and caverns Here is an image generated using 2D Perlin noise and a 3D interpretation of that image as terrain. This was my initial starting point. Check out the . live demo of this here Basic Perlin noise and a 3D representation This does generate an elevation profile but some work was needed to get more of that island feel and make it more realistic. Getting in Shape In order to obtain an island shape, the elevation of the terrain needed to approach sea level as it got closer to the edges of the map. This was easy enough. You can . see the code here with the island configurations enabled: This is what things look like Restricting Perlin noise based on distance from center of the island Mountains to Mole Hills The island at this stage was a bit boring. Additional detail needed to be added to give the user enough information at different scales to help them orient themselves better. If I zoom out, I should be able to pick out unique features from a bird’s eye view. If I zoom in to ground level, I should see enough elevation change at a smaller scale to orient me at a lower level. To frame this problem better in my mind I considered analogies from and . Things that have a fractal nature have a “scale free” characteristic. The level of details seems to stay the same at different scales. fractals self-similarity https://en.wikipedia.org/wiki/File:Fractal_tree_(Plate_b_-_2).jpg Trees can be considered fractals. If you cut off a branch from the tree and examine it, it looks, well, like a tree. There have even been that assign a fractal dimension to describe it’s scale-free behavior. It seems that using the fractal analogy was the right way to go. studies on mountainous terrain Simulating Scale-Free Terrain Perlin noise does a great job of giving enough detail for scale. I needed the same Perlin noise effect at different scales. ONE Naturally, some smart folks already figured out a nice solution. I simply needed to add additional layers of Perlin noise that are transformed at different scales. This is called adding “octaves”. Each octave is a layer of Perlin noise that is scaled by some factor so that it shrinks or expands the detail. Each octave is . then normalized and combined After I added just one octave of Perlin noise, . things immediately started looking better Two octaves total giving way to mountains and hills Turning the Knobs Ultimately, I ended up layering on 4 octaves that seemed to adequately provide the right amount of detail at each level of scale. It took some time to tweak the scale and the percent of elevation each octave contributed, but the . results look considerably more realistic Four total octaves gives detail at the macro and micro scales When you zoom in, you can see the right amount of detail to find points of interest. You can see distinct mountains far away, a few hills as you get closer, and bumps right at ground level. Mission accomplished!? Detail at many zoom levels allows the user to find points of interest useful for orienting themselves at different scales Applying the Technique I applied these simple techniques to my 3D world in the CMS. Check out the animation below that shows the different scales at which users interact in the Grasp Theory memory palace island and note the application of the Perlin noise techniques discussed in this article: Implementation using ThreeJS with custom shaders and LOD Terrain algorithms. Did it Really Work? My goal was to recall every memory palace added to the island. The initial results here are subjective, but promising. After placing just a few groups of memory palaces and a few pieces of content in each memory palace, I realized that this approach for me was very effective. You can stop me on the street at any time and I can tell you where on the island every memory palace is and what topic it is associated with. Additionally, I could draw you a nice picture of what you see when you look out from any memory palace including the minor hills and mountains in the distance. Quantifying the effectiveness will be something that comes as the software progresses and I’ll be sure to post again. Hopefully, this leads to new and fun ways to enhance and ! education learning Like this Article? Thanks! Consider giving this article some ! clappy claps Generate Your Own Island! and create your own terrain! Check out the live Perlin noise demo

Stories, News & Mentions about CHESSABLE

Chessable’s Stories on HackerNoon

Chessable's News & Mentions