Get the most recent info and news about BGR on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

BGR: The leading mobile and technology news source for breaking news, reviews, insights and opinions

If you buy through a <strong>BGR</strong> link, we may earn an affiliate commission, helping support our expert product labs.

It might be time for NASA to bail on Boeing's Starliner

Meet the Bot That Reads All the Bad News Headlines So You Don’t Have To

Γνωρίστε το Bot που διαβάζει όλους τους τίτλους των κακών ειδήσεων για να μην χρειάζεται

Conozca el bot que lee todos los titulares de malas noticias para que usted no tenga que hacerlo

Découvrez le robot qui lit tous les gros titres des mauvaises nouvelles pour que vous n'ayez pas à le faire

Հանդիպեք այն բոտին, որը կարդում է բոլոր վատ լուրերի վերնագրերը, որպեսզի դուք ստիպված չլինեք դա անել

Incontra il bot che legge tutti i titoli delle brutte notizie così non devi farlo tu

הכירו את הבוט שקורא את כל כותרות החדשות הרעות כדי שלא תצטרכו

悪いニュースの見出しをあなたが読む代わりに読んでくれるボットをご紹介します

ພົບກັບ Bot ທີ່ອ່ານທຸກຫົວຂໍ້ຂ່າວບໍ່ດີດັ່ງນັ້ນທ່ານບໍ່ຈໍາເປັນຕ້ອງ

Faceți cunoștință cu botul care citește toate titlurile știrilor proaste, astfel încât să nu aveți nevoie

Hura na Bot isoma amakuru yose mabi mumutwe kugirango utagomba

Бо бот вохӯред, ки ҳама сарлавҳаҳои хабарҳои бадро мехонад, то ба шумо лозим нест

Sizga kerak bo'lmasligi uchun barcha yomon yangiliklar sarlavhalarini o'qiydigan bot bilan tanishing

Welcome to the Beginners Guide to Polkadot API series! This particular tutorial will focus on learning how to build and compose decentralized applications (dApps) on the Polkadot network. We will also define what that means exactly, and how to get started with creating your first light client-powered dapp on Polkadot. In this tutorial, we will build a dead simple “You’ve Got Mail“ CLI app using the Polkadot API. build compose If you're new to Polkadot (and blockchain development) in general then keep on reading, otherwise, you can skip to the tutorial. Quick Introduction: What is Polkadot? Polkadot's is a protocol that coordinates and secures different rollups (often called parachains) allowing for a horizontally scaling, heterogeneously sharded, multi-chain approach to Web3. One of the keywords here is heterogeneously sharded, meaning that each shard, or blockchain (or state machine, if you want to get more technical), contains its unique domain-specific logic. Using the Polkadot SDK, anyone can build a rollup and inherit security from the Polkadot relay chain. A rollup can be quite literally anything from a bridge to Ethereum and other protocols (Hyperbridge), a decentralized knowledge graph️ (OriginTrail), or even a cloud computing and oracle platform that is powered by old smartphones (Acurast) coordinates secures heterogeneously sharded bridge to Ethereum and other protocols (Hyperbridge) a decentralized knowledge graph️ (OriginTrail) a cloud computing and oracle platform that is powered by old smartphones (Acurast) Once deployed, rollups can use cross-consensus messaging (XCM) to communicate with one another. This is not limited to just rollups within Polkadot, but even to other protocols, such as Ethereum. XCM Composing Applications Using the Polkadot Stack As Polkadot has a wide range of different application-specific rollups at our creative disposal, the concept of composing apps should not be a foreign one. Similar to how a traditional, web2 application may use different services, APIs, and technologies to build a fullstack application, we can utilize the different parts of the Polkadot stack to build a web3 native application. You even go as far as to host your application on a web3 service to completely bypass the conventional means of deployment. composing The Composer - The Polkadot API (PAPI) Although you can use a number of languages to build apps on Polkadot, such as Rust, Python, or Typescript/Javascript, we'll be using Polkadot API, or PAPI, which is a Typescript library for interacting with Polkadot (and its rollups). The main differentiator with PAPI is its light-client-first approach, in which it has native support for communicating to Polkadot via a light client. Polkadot API Polkadot API PAPI The light client implementation, called smoldot, runs in the background and ensures that we have the latest, verified chain state. Using PAPI, you can even interact with multiple rollups on Polkadot at once. smoldot Why Are Light Clients Important? Light clients are one of the two options for connecting to a blockchain, with the other usually depending on a single RPC provider (which often runs on a centralized server). They are typically a more secure, trust-minimized, efficient way of communicating to a blockchain. Light clients verify the state of the blockchain using Merkle proofs, ensuring it has not only the latest but correct state. As it just verifies the headers of the blocks, it has no need to download the whole state, making it ideal for resource-constrained environments. correct Unlike RPC connections, they do not depend on a single RPC provider and can be embedded in both the browser and natively. "You've Got Mail!" - Polkadot API Example With the explanation out of the way, let's get our hands dirty with some code. Project Introduction Our project will be quite simple - it will be a CLI application that runs in the terminal, which watches the relay chain for a certain extrinsic (a transaction). This extrinsic will be the system.remarkWithEvent extrinsic, meaning it is coming from the system pallet (module) on the Westend test network. extrinsic system.remarkWithEvent system The system.remarkWithEvent extrinsic allows us to send any arbitrary data on-chain, with the end result being a hash that is the address and the word "email" combined (address+email). We'll hash this combination and watch for remarks on a chain that are addressed to us. The system.remarkWithEvent extrinsic emits an event that we can use PAPI to watch the chain for. system.remarkWithEvent address+email system.remarkWithEvent Once we receive a remark addressed to us, we will play the infamous "You've Got Mail!" sound byte. Prerequisites You should have the following installed as a prerequisite: npm (or other package manager)
node
git
Polkadot.js Browser Extension (wallet) npm (or other package manager) npm node node git git Polkadot.js Browser Extension (wallet) Polkadot.js Browser Extension (wallet) You will also need an account with Westend tokens. Below you can find guides for both Polkadot.js and the faucet: Creating Accounts on Polkadot.js
Westend Faucet Creating Accounts on Polkadot.js Creating Accounts on Polkadot.js Westend Faucet Westend Faucet Cloning the repository For this tutorial, you can choose to run the example directly by cloning the main branch of the repository, or to use a boilerplate/template and follow the tutorial. main branch of the repository We need to clone the template, which has everything we need to get started with the Polkadot API and Typescript. Be sure you clone the correct branch (empty-cli) which already provides all dependencies: empty-cli git clone https://github.com/CrackTheCode016/polkadot-api-example-cli --branch empty-cli git clone https://github.com/CrackTheCode016/polkadot-api-example-cli --branch empty-cli Once cloned, run the following to ensure npm dependencies are installed: npm cd polkadot-api-example-cli
npm install cd polkadot-api-example-cli
npm install Exploring the Template (Light Clients!) When we open the repository, we should see the following code (excluding imports): async function withLightClient(): Promise<PolkadotClient> {
    // Start the light client
    const smoldot = start();
    // The Westend Relay Chain
    const relayChain = await smoldot.addChain({ chainSpec: westEndChainSpec })
    return createClient(
        getSmProvider(relayChain)
    );
}

async function main() {
    // CLI Code goes here...
}

main() async function withLightClient(): Promise<PolkadotClient> {
    // Start the light client
    const smoldot = start();
    // The Westend Relay Chain
    const relayChain = await smoldot.addChain({ chainSpec: westEndChainSpec })
    return createClient(
        getSmProvider(relayChain)
    );
}

async function main() {
    // CLI Code goes here...
}

main() The notable function to pay attention to is the withLightClient function. This function uses the built in light client functionality (powered by smoldot) to actually create a light client that syncs and interacts with Polkadot right there in our application. withLightClient smoldot Creating the CLI Next, let's create our CLI, which is to be done within the confines of the main function. We will include an option (-a / --account), which will be the account we will watch for our "mail": main -a --account const program = new Command();
console.log(chalk.white.dim(figlet.textSync("Web3 Mail Watcher")));
program.version('0.0.1').description('Web3 Mail Watcher - A simple CLI tool to watch for remarks on Polkadot network');
    .option('-a, --account <account>', 'Account to watch')
    .parse(process.argv);

// CLI Arguments from commander
const options = program.opts(); const program = new Command();
console.log(chalk.white.dim(figlet.textSync("Web3 Mail Watcher")));
program.version('0.0.1').description('Web3 Mail Watcher - A simple CLI tool to watch for remarks on Polkadot network');
    .option('-a, --account <account>', 'Account to watch')
    .parse(process.argv);

// CLI Arguments from commander
const options = program.opts(); Watching for Remarks Next, we need to start watching the Westend network for remarks sent to our account. As was done before, all code should be within the main function: main // We check for the --account flag, if its not provided we exit
    if (options.account) {
        console.log(chalk.black.bgRed("Watching account:"), chalk.bold.whiteBright(options.account));
        // We create a light client to connect to the Polkadot (Westend) network
        const lightClient = await withLightClient();
        // We get the typed API to interact with the network
        const dotApi = lightClient.getTypedApi(wnd);
        // We subscribe to the System.Remarked event and watch for remarks from our account
        dotApi.event.System.Remarked.watch().subscribe((event) => {
            // We look for a specific hash, indicating that its our address + an email
            const { sender, hash } = event.payload;
            // We calculate the hash of our account + email
            const calculatedHash = bytesToHex(blake2b(`${options.account}+email`, { dkLen: 32 }));
            // If the hash matches, we play a sound and log the message - You got mail!
            if (`0x${calculatedHash}` == hash.asHex()) {
                sound.play("youve-got-mail-sound.mp3")
                console.log(chalk.black.bgRed(`You got mail!`));
                console.log(chalk.black.bgCyan("From:"), chalk.bold.whiteBright(sender.toString()));
                console.log(chalk.black.bgBlue("Hash:"), chalk.bold.whiteBright(hash.asHex()));
            }
        });
    } else {
        // If the account is not provided, we exit
        console.error('Account is required');
        return;
    } // We check for the --account flag, if its not provided we exit
    if (options.account) {
        console.log(chalk.black.bgRed("Watching account:"), chalk.bold.whiteBright(options.account));
        // We create a light client to connect to the Polkadot (Westend) network
        const lightClient = await withLightClient();
        // We get the typed API to interact with the network
        const dotApi = lightClient.getTypedApi(wnd);
        // We subscribe to the System.Remarked event and watch for remarks from our account
        dotApi.event.System.Remarked.watch().subscribe((event) => {
            // We look for a specific hash, indicating that its our address + an email
            const { sender, hash } = event.payload;
            // We calculate the hash of our account + email
            const calculatedHash = bytesToHex(blake2b(`${options.account}+email`, { dkLen: 32 }));
            // If the hash matches, we play a sound and log the message - You got mail!
            if (`0x${calculatedHash}` == hash.asHex()) {
                sound.play("youve-got-mail-sound.mp3")
                console.log(chalk.black.bgRed(`You got mail!`));
                console.log(chalk.black.bgCyan("From:"), chalk.bold.whiteBright(sender.toString()));
                console.log(chalk.black.bgBlue("Hash:"), chalk.bold.whiteBright(hash.asHex()));
            }
        });
    } else {
        // If the account is not provided, we exit
        console.error('Account is required');
        return;
    } This code is doing quite a bit, so let's break it down: First, we check for the existance of the --account argument, and log that we are watching that account, else we exit. We are using the chalk package to add color to our console.log statements.
Next, we create our light client.
We use a light client and the Westend chain specification (wnd) to access a typed API.
Once we have our API, we then begin to reactively watch the account for the event that corresponds to the remark. We analyze the payload, looking for a hash which is calculated as follows:

hash of: account_address+email


When an event containing this hash is identified, it then plays the "You've Got Mail!" soundbite. First, we check for the existance of the --account argument, and log that we are watching that account, else we exit. We are using the chalk package to add color to our console.log statements. --account chalk console.log Next, we create our light client. We use a light client and the Westend chain specification (wnd) to access a typed API. wnd Once we have our API, we then begin to reactively watch the account for the event that corresponds to the remark. We analyze the payload, looking for a hash which is calculated as follows:

hash of: account_address+email hash of: account_address+email hash of: account_address+email account_address+email When an event containing this hash is identified, it then plays the "You've Got Mail!" soundbite. Compiling and running Once we have all of our code in place, we should compile and run the repository: npm start -- --account <account-address> npm start -- --account <account-address> Upon running, we should have the following output: ❯ npm start -- --account 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY

> youve-got-mail-web3@1.0.0 start
> tsc && node ./dist/index.js --account 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY

 __        __   _    _____   __  __       _ _  __        __    _       _
 \ \      / /__| |__|___ /  |  \/  | __ _(_) | \ \      / /_ _| |_ ___| |__   ___ _ __
  \ \ /\ / / _ \ '_ \ |_ \  | |\/| |/ _` | | |  \ \ /\ / / _` | __/ __| '_ \ / _ \ '__|
   \ V  V /  __/ |_) |__) | | |  | | (_| | | |   \ V  V / (_| | || (__| | | |  __/ |
    \_/\_/ \___|_.__/____/  |_|  |_|\__,_|_|_|    \_/\_/ \__,_|\__\___|_| |_|\___|_|

Watching account: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
[smoldot] Smoldot v2.0.34
[smoldot] Chain initialization complete for westend2. Name: "Westend". Genesis hash: 0xe143…423e. Chain specification starting at: 0x10cf…b908 (#23920337) ❯ npm start -- --account 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY

> youve-got-mail-web3@1.0.0 start
> tsc && node ./dist/index.js --account 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY

 __        __   _    _____   __  __       _ _  __        __    _       _
 \ \      / /__| |__|___ /  |  \/  | __ _(_) | \ \      / /_ _| |_ ___| |__   ___ _ __
  \ \ /\ / / _ \ '_ \ |_ \  | |\/| |/ _` | | |  \ \ /\ / / _` | __/ __| '_ \ / _ \ '__|
   \ V  V /  __/ |_) |__) | | |  | | (_| | | |   \ V  V / (_| | || (__| | | |  __/ |
    \_/\_/ \___|_.__/____/  |_|  |_|\__,_|_|_|    \_/\_/ \__,_|\__\___|_| |_|\___|_|

Watching account: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
[smoldot] Smoldot v2.0.34
[smoldot] Chain initialization complete for westend2. Name: "Westend". Genesis hash: 0xe143…423e. Chain specification starting at: 0x10cf…b908 (#23920337) Testing the CLI Now that our application is actively watching for remark events on-chain, we can move to testing to see if it works! As mentioned previously, you will need a Westend account with some tokens to pay for fees. As mentioned previously, you will need a Westend account with some tokens to pay for fees. Navigate to the PAPI Dev Console > Extrinsics. You then want to select the System pallet, and the remark_with_event call: PAPI Dev Console > Extrinsics System remark_with_event Next, we want to be sure we get the correct input for the text field. We want to be sure we are following the convention we set forth in our application: address+email address+email address+email address+email If for example, we are watching 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY, then the field should look like the following: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY Once this input is in place, you may click the Submit extrinsic button, where you can sign using the Polkadot.js browser wallet: Submit extrinsic Heading back to our CLI, we should soon see the following, along with the fact that "YOU'VE GOT MAIL!" (as in the sound should play): __        __   _    _____   __  __       _ _  __        __    _       _
 \ \      / /__| |__|___ /  |  \/  | __ _(_) | \ \      / /_ _| |_ ___| |__   ___ _ __
  \ \ /\ / / _ \ '_ \ |_ \  | |\/| |/ _` | | |  \ \ /\ / / _` | __/ __| '_ \ / _ \ '__|
   \ V  V /  __/ |_) |__) | | |  | | (_| | | |   \ V  V / (_| | || (__| | | |  __/ |
    \_/\_/ \___|_.__/____/  |_|  |_|\__,_|_|_|    \_/\_/ \__,_|\__\___|_| |_|\___|_|

Watching account: 5Cm8yiG45rqrpyV2zPLrbtr8efksrRuCXcqcB4xj8AejfcTB
You've got mail!
From: 5Cm8yiG45rqrpyV2zPLrbtr8efksrRuCXcqcB4xj8AejfcTB
Hash: 0xb6999c9082f5b1dede08b387404c9eb4eb2deee4781415dfa7edf08b87472050 __        __   _    _____   __  __       _ _  __        __    _       _
 \ \      / /__| |__|___ /  |  \/  | __ _(_) | \ \      / /_ _| |_ ___| |__   ___ _ __
  \ \ /\ / / _ \ '_ \ |_ \  | |\/| |/ _` | | |  \ \ /\ / / _` | __/ __| '_ \ / _ \ '__|
   \ V  V /  __/ |_) |__) | | |  | | (_| | | |   \ V  V / (_| | || (__| | | |  __/ |
    \_/\_/ \___|_.__/____/  |_|  |_|\__,_|_|_|    \_/\_/ \__,_|\__\___|_| |_|\___|_|

Watching account: 5Cm8yiG45rqrpyV2zPLrbtr8efksrRuCXcqcB4xj8AejfcTB
You've got mail!
From: 5Cm8yiG45rqrpyV2zPLrbtr8efksrRuCXcqcB4xj8AejfcTB
Hash: 0xb6999c9082f5b1dede08b387404c9eb4eb2deee4781415dfa7edf08b87472050 Conclusion This application can be expanded in a number of ways, whether that is by adding a chatroom through remarks, or by using some of the rollups on Polkadot to expand the functionality. If you have any ideas, questions, comments, or concerns, feel free to shoot me a message here on X! X

Everything You Need to Know About The Polkadot API (PAPI)

Weather Image Recognition with AI: Dataset Labeling, Model Training, and Real-world Usecases

Want to Search for Something With an Image and a Text Description? Try a Multimodal RAG

¿Mä Imagen ukat Texto Descripción ukampi kuns thaqhañ munasmati? Mä RAG Multimodal ukamp yant’aña

¿Quieres buscar algo con una imagen y una descripción de texto? Prueba un RAG multimodal

آیا می خواهید چیزی را با یک تصویر و یک توضیح متنی جستجو کنید؟ یک RAG Multimodal را امتحان کنید

Vous souhaitez rechercher quelque chose avec une image et une description textuelle ? Essayez un RAG multimodal

画像とテキストの説明を使って何かを検索したいですか? マルチモーダル RAG をお試しください

ចង់ស្វែងរកអ្វីមួយដែលមានរូបភាព និងការពិពណ៌នាអត្ថបទ? សាកល្បងប្រើ Multimodal RAG

Зураг болон текстийн тайлбартай ямар нэг зүйл хайхыг хүсч байна уу? Multimodal RAG-г туршаад үзээрэй

Ingin Mencari Sesuatu Dengan Imej dan Penerangan Teks? Cuba RAG Multimodal

غواړئ د عکس او متن توضیحاتو سره یو څه وپلټئ؟ د ملټي موډل RAG هڅه وکړئ

රූපයක් සහ පෙළ විස්තරයක් සමඟ යමක් සෙවීමට අවශ්‍යද? Multimodal RAG එකක් උත්සාහ කරන්න

ต้องการค้นหาบางสิ่งที่มีรูปภาพและคำอธิบายหรือไม่ ลองใช้ RAG แบบหลายโหมด

Surat we tekst beýany bilen bir zat gözlemek isleýärsiňizmi? Multimodal RAG synap görüň

How I Created AI Photocraft: An AI SaaS Tool Using Open Source Projects on GitHub

The vast majority of modern systems are built on a microservice architecture. This means that you can be the maintainer of about a hundred services, which are being worked on by several teams of software engineers. As the person responsible for the system, it is important for you to monitor the relevance of the master branch of all projects. One of the easiest and fastest ways to do this is to check how much your main project branch lags behind the test branch after the release. Thanks to this simple check, you will be sure that the teams have brought all the services to production. Also, a quick report on the lag of the master branch from dev will be useful for understanding the state of development. If more than a few hundred commits have accumulated in the dev branch, then this is a red flag and you, as a team lead, should raise this issue at the sprint retro, because it is obvious that there were interruptions in the process of delivering improvements to production. To solve the problem of quickly viewing ahead/behind my projects, I use the rest API for GitLab (https://docs.gitlab.com/ee/api/rest/), which provides me with all the necessary capabilities. As a language, I chose JavaScript without frameworks, because we have a fast development for ourselves, which should not require a special environment. As a result of the script's work, I want to see a table with columns in the console: group_id - gitlab project group id
group_name - the name of the project group
id - project id
name - project name
behind - how many commits is the master branch ahead of the dev
ahead - how many commits is the dev branch ahead of the master To access the data, I will use a personal access token, which can be obtained in the settings of my GitLab profile. First, I'll get a list of groups using the/api/v4/groups method. After that, I need to get a list of project repositories using the /api/v4/groups/${group.id}/projects method. All that remains is to get the number of commits using the /api/v4/projects/${project.id}/repository/compare method. Next, I collect the data in a table, perform a sorting that is convenient for me, and highlight problematic lines. To perform REST requests, I use axios, and to output a table with data, I use the console-table-printer project. As a result, I got the following script. const { Table } = require('console-table-printer');
const axios = require('axios');

const token = token';
const baseUrl = 'https://git.my-company.net';
const from = 'master';
const to = 'dev';

(async () => {
    let data = [];
    const groups = await axios
        .get(`${baseUrl}/api/v4/groups?private_token=${token}`)
        .then(res => res.data);

    await Promise.all(groups.map(async (group) => {
        const projects = await axios
            .get(`${baseUrl}/api/v4/groups/${group.id}/projects?per_page=100&private_token=${token}`)
            .then(res => res.data);

        await Promise.all(projects.map(async (project) => {
            const behind = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${from}&to=${to}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            const ahead = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${to}&to=${from}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            if (behind && behind.commits && ahead && ahead.commits){
                data.push({
                    group_id: group.id,
                    group_name: group.name,
                    id: project.id,
                    name: project.name,
                    behind: behind.commits.length,
                    ahead: ahead.commits.length,
                });
            }
        }));
    }))

    data = data
        .sort((a,b) =>
            (a.group_name > b.group_name)
                ? 1
                : ((b.group_name > a.group_name) ? -1
                    : (a.name > b.name)
                        ? 1
                        : ((b.name > a.name) ? -1 : 0)));

    const table = new Table();
    data.forEach((row) => {
        table.addRow(row, {
            color: row.behind ? 'red' : undefined,
        });
    });
    table.printTable();
})(); After its execution, the following table is output to the console: group_id

group_name

id

name

behind

ahead



235

common

34

common_service

5

2



235

common

455

master_data

0

0



379

core

453

core_service

7

0



379

core

344

core_tasks

3

1 The vast majority of modern systems are built on a microservice architecture. This means that you can be the maintainer of about a hundred services, which are being worked on by several teams of software engineers. As the person responsible for the system, it is important for you to monitor the relevance of the master branch of all projects. One of the easiest and fastest ways to do this is to check how much your main project branch lags behind the test branch after the release. Thanks to this simple check, you will be sure that the teams have brought all the services to production. Also, a quick report on the lag of the master branch from dev will be useful for understanding the state of development. If more than a few hundred commits have accumulated in the dev branch, then this is a red flag and you, as a team lead, should raise this issue at the sprint retro, because it is obvious that there were interruptions in the process of delivering improvements to production. To solve the problem of quickly viewing ahead/behind my projects, I use the rest API for GitLab ( https://docs.gitlab.com/ee/api/rest/ ), which provides me with all the necessary capabilities. https://docs.gitlab.com/ee/api/rest/ As a language, I chose JavaScript without frameworks, because we have a fast development for ourselves, which should not require a special environment. As a result of the script's work, I want to see a table with columns in the console: group_id - gitlab project group id group_name - the name of the project group id - project id name - project name behind - how many commits is the master branch ahead of the dev ahead - how many commits is the dev branch ahead of the master group_id - gitlab project group id group_name - the name of the project group id - project id name - project name behind - how many commits is the master branch ahead of the dev ahead - how many commits is the dev branch ahead of the master To access the data, I will use a personal access token, which can be obtained in the settings of my GitLab profile. First, I'll get a list of groups using the /api/v4/groups method. /api/v4/groups After that, I need to get a list of project repositories using the /api/v4/groups/${group.id}/projects method. /api/v4/groups/${group.id}/projects All that remains is to get the number of commits using the /api/v4/projects/${project.id}/repository/compare method. /api/v4/projects/${project.id}/repository/compare Next, I collect the data in a table, perform a sorting that is convenient for me, and highlight problematic lines. To perform REST requests, I use axios , and to output a table with data, I use the console-table-printer project. As a result, I got the following script. axios console-table-printer const { Table } = require('console-table-printer');
const axios = require('axios');

const token = token';
const baseUrl = 'https://git.my-company.net';
const from = 'master';
const to = 'dev';

(async () => {
    let data = [];
    const groups = await axios
        .get(`${baseUrl}/api/v4/groups?private_token=${token}`)
        .then(res => res.data);

    await Promise.all(groups.map(async (group) => {
        const projects = await axios
            .get(`${baseUrl}/api/v4/groups/${group.id}/projects?per_page=100&private_token=${token}`)
            .then(res => res.data);

        await Promise.all(projects.map(async (project) => {
            const behind = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${from}&to=${to}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            const ahead = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${to}&to=${from}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            if (behind && behind.commits && ahead && ahead.commits){
                data.push({
                    group_id: group.id,
                    group_name: group.name,
                    id: project.id,
                    name: project.name,
                    behind: behind.commits.length,
                    ahead: ahead.commits.length,
                });
            }
        }));
    }))

    data = data
        .sort((a,b) =>
            (a.group_name > b.group_name)
                ? 1
                : ((b.group_name > a.group_name) ? -1
                    : (a.name > b.name)
                        ? 1
                        : ((b.name > a.name) ? -1 : 0)));

    const table = new Table();
    data.forEach((row) => {
        table.addRow(row, {
            color: row.behind ? 'red' : undefined,
        });
    });
    table.printTable();
})(); const { Table } = require('console-table-printer');
const axios = require('axios');

const token = token';
const baseUrl = 'https://git.my-company.net';
const from = 'master';
const to = 'dev';

(async () => {
    let data = [];
    const groups = await axios
        .get(`${baseUrl}/api/v4/groups?private_token=${token}`)
        .then(res => res.data);

    await Promise.all(groups.map(async (group) => {
        const projects = await axios
            .get(`${baseUrl}/api/v4/groups/${group.id}/projects?per_page=100&private_token=${token}`)
            .then(res => res.data);

        await Promise.all(projects.map(async (project) => {
            const behind = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${from}&to=${to}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            const ahead = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${to}&to=${from}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            if (behind && behind.commits && ahead && ahead.commits){
                data.push({
                    group_id: group.id,
                    group_name: group.name,
                    id: project.id,
                    name: project.name,
                    behind: behind.commits.length,
                    ahead: ahead.commits.length,
                });
            }
        }));
    }))

    data = data
        .sort((a,b) =>
            (a.group_name > b.group_name)
                ? 1
                : ((b.group_name > a.group_name) ? -1
                    : (a.name > b.name)
                        ? 1
                        : ((b.name > a.name) ? -1 : 0)));

    const table = new Table();
    data.forEach((row) => {
        table.addRow(row, {
            color: row.behind ? 'red' : undefined,
        });
    });
    table.printTable();
})(); After its execution, the following table is output to the console: group_id

group_name

id

name

behind

ahead



235

common

34

common_service

5

2



235

common

455

master_data

0

0



379

core

453

core_service

7

0



379

core

344

core_tasks

3

1 group_id

group_name

id

name

behind

ahead 235

common

34

common_service

5

2 235

common

455

master_data

0

0 379

core

453

core_service

7

0 379

core

344

core_tasks

3

1 group_id group_name id name behind ahead group_id group_id group_name group_name id id name name behind behind ahead ahead 235 common 34 common_service 5 2 235 235 common common 34 34 common_service common_service 5 5 2 2 235 common 455 master_data 0 0 235 235 common common 455 455 master_data master_data 0 0 0 0 379 core 453 core_service 7 0 379 379 core core 453 453 core_service core_service 7 7 0 0 379 core 344 core_tasks 3 1 379 379 core core 344 344 core_tasks core_tasks 3 3 1 1

Git Ahead Dashboard: A Quick Guide

Building a Logo Creation App with Next.js, Shadcn/ui, and Lucide React

Building Advanced Video Search: Frame Search Versus Multi-Modal Embeddings

উন্নত ভিডিও অনুসন্ধান তৈরি করা: ফ্রেম অনুসন্ধান বনাম মাল্টি-মোডাল এম্বেডিং

Erstellen einer erweiterten Videosuche: Frame-Suche im Vergleich zu multimodalen Einbettungen

Creación de búsqueda de vídeo avanzada: búsqueda de fotogramas frente a incrustaciones multimodales

Création d'une recherche vidéo avancée : recherche de trames et intégrations multimodales

उन्नत वीडियो खोज का निर्माण: फ़्रेम खोज बनाम मल्टी-मोडल एम्बेडिंग

高度なビデオ検索の構築: フレーム検索とマルチモーダル埋め込み

고급 비디오 검색 구축: 프레임 검색과 다중 모드 임베딩 비교

Construindo pesquisa avançada de vídeo: pesquisa de quadros versus incorporações multimodais

Создание расширенного поиска видео: поиск кадров в сравнении с мультимодальными встраиваниями

Gelişmiş Video Arama Oluşturma: Çerçeve Aramaya Karşı Çok Modlu Yerleştirmeler

Xây dựng Tìm kiếm video nâng cao: Tìm kiếm khung so với nhúng đa phương thức

构建高级视频搜索：帧搜索与多模态嵌入

Video Scene Location Recognition Using AI: Methodology

Moving to the upcoming WebGPU means more than just switching graphics APIs. It's also a step towards the future of web graphics. But this migration will turn out better with preparation and understanding — and this article will get you ready. Hello everyone, my name is Dmitrii Ivashchenko and I'm a software engineer at MY.GAMES. In this article, we'll discuss the differences between WebGL and the upcoming WebGPU, and we'll lay out how to prepare your project for migration. Content Overview Timeline of WebGL and WebGPU The current state of WebGPU, and what's to come High-level Conceptual Differences Initialization • WebGL: The Context Model • WebGPU: The Device Model Programs and Pipelines • WebGL: Program • WebGPU: Pipeline Uniforms • Uniforms in WebGL 1 • Uniforms in WebGL 2 • Uniforms in WebGPU Shaders • Shader Language: GLSL vs WGSL • Comparison of Data Types • Structures • Function Declarations • Built-in functions • Shader Conversion Convention Differences Textures • Viewport Space • Clip Spaces WebGPU Tips & Tricks • Minimize the number of pipelines you use. • Create pipelines in advance • Use RenderBundles Summary Timeline of WebGL and WebGPU , like many other web technologies, has roots that stretch back quite far into the past. To understand the dynamics and motivation behind the move towards WebGPU, it's helpful to first take a quick look at the history of WebGL development: WebGL The desktop version of OpenGL debuts. OpenGL desktop (1993) : This was the first stable release of WebGL, based on OpenGL ES 2.0, which was itself introduced in 2007. It provided web developers with the ability to use 3D graphics directly in browsers, without the need for additional plugins. WebGL 1.0 (2011) : Introduced six years after the first version, WebGL 2.0 was based on OpenGL ES 3.0 (2012). This version brought with it a number of improvements and new capabilities, making 3D graphics on the web even more powerful. WebGL 2.0 (2017) In recent years, there has been a surge of interest in new graphics APIs that provide developers with more control and flexibility: : Created by the Khronos group, this cross-platform API is the "successor" to OpenGL. Vulkan provides lower-level access to graphics hardware resources, allowing for high-performance applications with better control over graphics hardware. Vulkan (2016) : This API was created by Microsoft and is exclusively for Windows and Xbox. D3D12 is the successor to D3D10/11 and provides developers with deeper control over graphics resources. D3D12 (2015) : Created by Apple, Metal is an exclusive API for Apple devices. It was designed with maximum performance on Apple hardware in mind. Metal (2014) The current state of WebGPU, and what's to come Today, WebGPU is available on multiple platforms such as Windows, Mac, and ChromeOS through the Google Chrome and Microsoft Edge browsers, starting with version 113. Support for Linux and Android is expected in the near future. Here are some of the engines that already support (or offer experimental support) for WebGPU: : Full support for WebGPU. Babylon JS : Experimental support at the moment. ThreeJS : In development, but with very promising prospects. PlayCanvas : Very early and experimental WebGPU support was announced in version 2023.2 alpha. Unity : Officially supports WebGPU, making it one of the pioneers in this area. Cocos Creator 3.6.2 : currently supported in v113+ for Windows, macOS, and ChromeOS only. Construct Considering this, transitioning to WebGPU or at least preparing projects for such a transition appears to be a timely step in the near future. High-level Conceptual Differences Let's zoom out and take a look at some of the high-level conceptual differences between WebGL and WebGPU, starting with initialization. Initialization When starting to work with graphics APIs, one of the first steps is to initialize the main object for interaction. This process differs between WebGL and WebGPU, with some peculiarities for both systems. WebGL: The Context Model In WebGL, this object is known as "context", which essentially represents an interface for drawing on an HTML5 canvas element. Obtaining this context is quite simple: const gl = canvas.getContext('webgl'); The context of WebGL is actually tied to a specific canvas. This means that if you need to render on multiple canvases, you will need multiple contexts. WebGPU: The Device Model WebGPU introduces a new concept called "device". This device represents a GPU abstraction that you will interact with. The initialization process is a bit more complex than in WebGL, but it provides more flexibility: const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const context = canvas.getContext('webgpu');
context.configure({
   device,
   format: 'bgra8unorm',
}); One of the advantages of this model is that one device can render on multiple canvases or even none. This provides additional flexibility; for example, one device may control rendering in multiple windows or contexts. Programs and Pipelines WebGL and WebGPU represent different approaches to managing and organizing the graphics pipeline. WebGL: Program In WebGL, the main focus is on the shader program. The program combines vertex and fragment shaders, defining how vertices should be transformed and how each pixel should be colored. const program = gl.createProgram();
gl.attachShader(program, vertShader);
gl.attachShader(program, fragShader);
gl.bindAttribLocation(program, 'position', 0);
gl.linkProgram(program); Steps for creating a program in WebGL: : The source code for shaders is written and compiled. Creating Shaders : Compiled shaders are attached to the program and then linked. Creating Program : The program is activated before rendering. Using Program : Data is transmitted to the activated program. Data Transmission This process allows for flexible graphics control, but can also be complex and prone to errors, especially for large and complex projects. WebGPU: Pipeline WebGPU introduces the concept of a "pipeline" instead of a separate program. This pipeline combines not only shaders but also other information, which in WebGL, is established as states. So, creating a pipeline in WebGPU looks more complex: const pipeline = device.createRenderPipeline({
 layout: 'auto',
 vertex: {
   module: shaderModule, entryPoint: 'vertexMain',
   buffers: [{
     arrayStride: 12,
     attributes: [{
       shaderLocation: 0, offset: 0, format: 'float32x3'
     }]
   }],
 },
 fragment: {
   module: shaderModule, entryPoint: 'fragmentMain',
   targets: [{ format, }],
 },
}); Steps to create a pipeline in WebGPU: : The shader source code is written and compiled, similar to how it's done in WebGL. Shader definition : Shaders and other rendering parameters are combined into a pipeline. Pipeline creation : The pipeline is activated before rendering. Pipeline usage While WebGL separates each aspect of rendering, WebGPU tries to encapsulate more aspects into a single object, making the system more modular and flexible. Instead of separately managing shaders and rendering states, as is done in WebGL, WebGPU combines everything into one pipeline object. This makes the process more predictable and less prone to errors: Uniforms Uniform variables provide constant data that is available to all shader instances. Uniforms in WebGL 1 In basic WebGL, we have the ability to set variables directly through API calls. uniform : GLSL uniform vec3 u_LightPos;
uniform vec3 u_LightDir;
uniform vec3 u_LightColor; : JavaScript const location = gl.getUniformLocation(p, "u_LightPos");
gl.uniform3fv(location, [100, 300, 500]); This method is simple, but requires multiple API calls for each variable. uniform Uniforms in WebGL 2 With the arrival of WebGL 2, we now have the ability to group variables into buffers. Although you can still use separate uniform shaders, a better option is to group different uniforms into a larger structure using uniform buffers. Then you send all this uniform data to the GPU at once, similar to how you can load a vertex buffer in WebGL 1. This has several performance advantages, such as reducing API calls and being closer to how modern GPUs work. uniform : GLSL layout(std140) uniform ub_Params {
   vec4 u_LightPos;
   vec4 u_LightDir;
   vec4 u_LightColor;
}; : JavaScript gl.bindBufferBase(gl.UNIFORM_BUFFER, 1, gl.createBuffer()); To bind subsets of a large uniform buffer in WebGL 2, you can use a special API call known as . In WebGPU, there is something similar called dynamic uniform buffer offsets where you can pass a list of offsets when calling the API. bindBufferRange setBindGroup Uniforms in WebGPU WebGPU offers us an even better method. In this context, individual variables are no longer supported, and work is done exclusively through buffers. uniform uniform : WGSL [[block]] struct Params {
   u_LightPos : vec4<f32>;
   u_LightColor : vec4<f32>;
   u_LightDirection : vec4<f32>;
};
[[group(0), binding(0)]] var<uniform> ub_Params : Params; : JavaScript const buffer = device.createBuffer({
  usage: GPUBufferUsage.UNIFORM,
  size: 8
}); Modern GPUs prefer data to be loaded in one large block, rather than many small ones. Instead of recreating and rebinding small buffers each time, consider creating one large buffer and using different parts of it for different draw calls. This approach can significantly increase performance. WebGL is more imperative, resetting global state with each call, and striving to be as simple as possible. WebGPU, on the other hand, aims to be more object-oriented and focused on resource reuse, which leads to efficiency. Transitioning from WebGL to WebGPU may seem difficult due to differences in methods. However, starting with a transition to WebGL 2 as an intermediate step can simplify your life. Shaders Migrating from WebGL to WebGPU requires changes not only in the API, but also in shaders. The WGSL specification is designed to make this transition smooth and intuitive, while maintaining efficiency and performance for modern GPUs. Shader Language: GLSL vs WGSL WGSL is designed to be a bridge between WebGPU and native graphics APIs. Compared to GLSL, WGSL looks a bit more verbose, but the structure remains familiar. Here's an example shader for texture: : GLSL sampler2D myTexture;
varying vec2 vTexCoord;
void main() {
  return texture(myTexture, vTexCoord);
} : WGSL [[group(0), binding(0)]] var mySampler: sampler;
[[group(0), binding(1)]] var myTexture: texture_2d<f32>;
[[stage(fragment)]]
fn main([[location(0)]] vTexCoord: vec2<f32>) -> [[location(0)]] vec4<f32> {
  return textureSample(myTexture, mySampler, vTexCoord);
} Comparison of Data Types The table below shows a comparison of the basic and matrix data types in GLSL and WGSL: Transitioning from GLSL to WGSL demonstrates a desire for stricter typing and explicit definition of data sizes, which can improve code readability and reduce the likelihood of errors. Structures The syntax for declaring structures has also changed: GLSL: struct Light {
  vec3 position;
  vec4 color;
  float attenuation;
  vec3 direction;
  float innerAngle;
  float angle;
  float range;
}; WGSL: struct Light {
  position: vec3<f32>,
  color: vec4<f32>,
  attenuation: f32,
  direction: vec3<f32>,
  innerAngle: f32,
  angle: f32,
  range: f32,
}; Introducing explicit syntax for declaring fields in WGSL structures emphasizes the desire for greater clarity and simplifies understanding of data structures in shaders. Function Declarations : GLSL float saturate(float x) {
	return clamp(x, 0.0, 1.0);
} : WGSL fn saturate(x: f32) -> f32 {
  return clamp(x, 0.0, 1.0);
} Changing the syntax of functions in WGSL reflects the unification of the approach to declarations and return values, making the code more consistent and predictable. Built-in functions In WGSL, many built-in GLSL functions have been renamed or replaced. For example: Renaming built-in functions in WGSL not only simplifies their names, but also makes them more intuitive, which can facilitate the transition process for developers familiar with other graphics APIs. Shader Conversion For those who are planning to convert their projects from WebGL to WebGPU, it's important to know that there are tools for automatically converting GLSL to WGSL, such as **[Naga](https://github.com/gfx-rs/naga/)**, which is a Rust library for converting GLSL to WGSL. It can even work right in your browser with the help of WebAssembly. Here are Naga supported end-points: Convention Differences Textures After migration, you may encounter a surprise in the form of flipped images. Those who have ever ported applications from OpenGL to Direct3D (or vice versa) have already faced this classic problem. In the context of OpenGL and WebGL, textures are usually loaded in such a way that the starting pixel corresponds to the bottom left corner. However, in practice, many developers load images starting from the top left corner, which leads to the flipped image error. Nevertheless, this error can be compensated by other factors, ultimately leveling out the problem. Unlike OpenGL, systems such as Direct3D and Metal traditionally use the upper-left corner as the starting point for textures. Considering that this approach seems to be the most intuitive for many developers, the creators of WebGPU decided to follow this practice. Viewport Space If your WebGL code selects pixels from the frame buffer, be prepared for the fact that WebGPU uses a different coordinate system. You may need to apply a simple "y = 1.0 - y" operation to correct the coordinates. Clip Spaces When a developer faces a problem where objects are clipped or disappear earlier than expected, this is often related to differences in the depth domain. There's a difference between WebGL and WebGPU in how they define the depth range of the clip space. While WebGL uses a range from -1 to 1, WebGPU uses a range from 0 to 1, similar to other graphics APIs such as Direct3D, Metal, and Vulkan. This decision was made due to several advantages of using a range from 0 to 1 that were identified while working with other graphics APIs. The main responsibility for transforming your model's positions into clip space lies with the projection matrix. The simplest way to adapt your code is to ensure that your projection matrix outputs results in the range of 0 to 1. For those using libraries such as gl-matrix, there is a simple solution: instead of using the function, you can use ; similar functions are available for other matrix operations. perspective perspectiveZO if (webGPU) {
	// Creates a matrix for a symetric perspective-view frustum
  // using left-handed coordinates
  mat4.perspectiveZO(out, Math.PI / 4, ...);
} else {
  // Creates a matrix for a symetric perspective-view frustum
  // based on the default handedness and default near
  // and far clip planes definition.
  mat4.perspective(out, Math.PI / 4, …);
} However, sometimes you may have an existing projection matrix and you can't change its source. In this case, to transform it into a range from 0 to 1, you can pre-multiply your projection matrix by another matrix that corrects the depth range. WebGPU Tips & Tricks Now, let's discuss some tips and tricks for working with WebGPU. Minimize the number of pipelines you use. The more pipelines you use, the more state switching you have, and the less performance; this may not be trivial, depending on where your assets come from. Create pipelines in advance Creating a pipeline and using it immediately may work, but this is not recommended. Instead, create functions that return immediately and start working on a different thread. When you use the pipeline, the execution queue needs to wait for pending pipeline creations to finish. This can result in significant performance issues. To avoid this, make sure to leave some time between creating the pipeline and first using it. Or, even better, use the variants! The promise resolves when the pipeline is ready to use, without any stalling. create*PipelineAsync device.createComputePipelineAsync({
 compute: {
   module: shaderModule,
   entryPoint: 'computeMain'
 }
}).then((pipeline) => {
  const commandEncoder = device.createCommandEncoder();
  const passEncoder = commandEncoder.beginComputePass();
  passEncoder.setPipeline(pipeline);
  passEncoder.setBindGroup(0, bindGroup);
  passEncoder.dispatchWorkgroups(128);
  passEncoder.end();
  device.queue.submit([commandEncoder.finish()]);
}); Use RenderBundles Render bundles are pre-recorded, partial, reusable render passes. They can contain most rendering commands (except for things like setting the viewport) and can be "replayed" as part of an actual render pass later on. const renderPass = encoder.beginRenderPass(descriptor);

renderPass.setPipeline(renderPipeline);
renderPass.draw(3);

renderPass.executeBundles([renderBundle]);

renderPass.setPipeline(renderPipeline);
renderPass.draw(3);

renderPass.end(); Render bundles can be executed alongside regular render pass commands. The render pass state is reset to defaults before and after every bundle execution. This is primarily done to reduce the JavaScript overhead of drawing. GPU performance remains the same regardless of the approach. Summary Transitioning to WebGPU means more than just switching graphics APIs. It's also a step towards the future of web graphics, combining successful features and practices from various graphics APIs. This migration requires a thorough understanding of technical and philosophical changes, but the benefits are significant. Useful Resources & Links: WebGPU — All of the cores, none of the canvas From WebGL to WebGPU in Construct by Alain Galvan Raw WebGPU tutorial by Brandon Jones WebGPU Best Practices WebGL + WebGPU Meetup - July 2023 Link

Migrating from WebGL to WebGPU

WebGL থেকে WebGPU-তে স্থানান্তরিত হচ্ছে

Migration von WebGL zu WebGPU

Migrando de WebGL a WebGPU

Migration de WebGL vers WebGPU

WebGL से WebGPU पर माइग्रेट किया जा रहा है

WebGL から WebGPU への移行

WebGL에서 WebGPU로 마이그레이션

Migrando de WebGL para WebGPU

Переход с WebGL на WebGPU

WebGL'den WebGPU'ya geçiş

Di chuyển từ WebGL sang WebGPU

从 WebGL 迁移到 WebGPU

Pipeless is an open source multimedia framework with a focus on AI.
Developers can build and deploy apps that manipulate audio and video in just minutes by allowing them to concentrate on the code, not on building and maintaining processing pipelines. easy to use For example, just with these simple lines of code: You can build an application that can recognize cats in any . video The rest of this article explains in detail what Pipeless is and how to use it. Do you prefer playing with the code to reading? Here is the with ready to run examples, including the . repo examples/cats directory The Problem AI/ML has taken the programming world by storm in the past few years. The number of public, freely available Computer Vision (CV) models is increasing really fast. Training over custom datasets is becoming easier every day, with transfer learning techniques and libraries like Keras or PyTorch everyone can train a model within hours. However, the actual processing of multimedia is still really hard. For example, all these CV models use RGB/BGR arrays as image input. If you want to use them with a picture, it is straightforward to convert it to an RGB array. In the case of a video, things start to get complicated really fast. They get relatively complex when developing locally, but it becomes even harder if you try to deploy a service that, for example, waits for a stream and when it arrives processes it in real-time to produce some data or modify the stream itself. Not to mention about handling different input media formats, streams encoded with different codecs, etc. How Pipeless works Let's use the computer vision example to explain in more detail the pain outlined in the previous section. Imagine you are building an app that detects cats on a video (this is one of the ready-to-run ). You will need to: examples Demux the video: open the container (for example mp4) to extract the individual streams (video, audio, subtitles, etc) Decode each stream: convert the encoded stream into a raw stream. In the case of a mp4 video stream this is equivalent to take the H.264 encoded frames and convert them into RGB frames. Process the video: you can now provide the RGB image as input of our computer vision model, for example, to obtain bounding boxes and then modify the frame by drawing a square over the cat face. Encode the stream: exactly the opposite of the decoding step. You have to pass the frames through an H.264 codec. Mux the new video: take our H.264 encoded video stream, take the audio stream again and create a mp4 container for them, including presentation timestamps for syncing the streams. The steps outlined above are the most basic pipeline you can build to work with video locally. There are some tools already, like OpenCV, that make it easy to iterate over the frames of a video within a for loop. That's great for learning and experimenting, however, not suitable for real apps running in production. At some point, you will need to deploy your app. Let's imagine you have a garden and a camera with a motion sensor and you want to know where your cat is at any moment. The camera will send video when it detects some motion. You will need to extend the basic pipeline above so it is able to recognize when there is a new stream to process. You also need to deploy your cat recognition model and maybe deploy a RTSP server that handles the input of the video stream and pass it to the processing pipeline, and finally send you the edited video. What started by simply using a public cat recognition model, ended up becoming really hard by virtue of having to set up ‘everything else’ around it. Here is where Pipeless comes in. It takes care of all the grunt work, automatically. By using Pipeless all you need to do for the above case is to take an RGB image, pass it through the model, draw the square and voila. You just saved some weeks of your life! This is exactly what was shown at the beginning of the article under the demo section. Pipeless Architecture Pipeless is designed to be easy to deploy in the cloud but also being able to run it locally with a single command. It has three main independent components, and all the components are communicated via messages using the lightweight Nanomsg Next generation Library (NNG): : takes care of reading/receiving the streams, decode and demux them into single frames. It sends raw frames to the workers to be processed following a round robin schedule. Input : takes care of executing the user’s applications (your applications). You can deploy any number of workers to process frames in parallel, this helps to increase the stream framerate when processing in real-time and distribute the “heavy” load over different computers. Worker : takes care of receiving the processed raw streams, encode them and mux them into the output container format, for example mp4. It allows you to send the video to an external URI, play it directly on the device screen or store it on a file. Output In addition, Pipeless doesn’t have too many dependencies, you just need a Gstreamer and Python installed in your system. Find the detailed list of requirements and versions . here Roadmap Right now Pipeless is supporting a limited set of functionality, however, we are actively working to add more every day. You can learn more about the currently supported input and output formats on the section of the readme. Do you need a new one? Create a pull request or ask for it creating a GitHub issue. Current State The current version is the very first one, and doesn’t support automatically deploying apps to production, however, this is one of the main features we will bring very soon. So, stay tuned! Do you like Pipeless? We would love to get your feedback and contributions. Comment your thoughts directly here. You can also help us by starring  the and sharing it with your friends! repository Also published . here

Creating Computer Vision Apps Without Building Media Pipelines

Not so long ago I got into poker, and in addition to that, I enjoy working with and decided that I would like to combine business with pleasure. I made a detection of objects that are on the poker table as well as added some analytics on the basis of which I could make decisions about my moves. computer vision General functioning of the program I should point out right away that I chose PokerStars as a game room and the most popular variety of poker - Texas Hold'em. The function of the program is to start an infinite loop that reads a certain area of the screen where the poker table is. When our (hero's) turn comes, a window with the following information pops up or is updated: what are the cards we currently hold; the cards that are now on the table; total pot; equity; of each player's position and bid. Visually it looks as follows: https://www.youtube.com/watch?v=vYqsw58T0b8&embedable=true Determining a hero's move Just below the hero’s cards, there is a small area that can be either black or gray: If this area is grayed out, it is our move, otherwise, it is our opponent's move. Since our image is static, we cut out this area by coordinates. Then we use the function, which is used to detect pixels in the image that are within a certain color range by passing the clipped image there, determine from the number of white pixels in the binary image whether that returned function is our move or not: inRange() res_img = self.img[self.cfg['hero_step_define']['y_0']:self.cfg['hero_step_define']['y_1'],
                           self.cfg['hero_step_define']['x_0']:self.cfg['hero_step_define']['x_1']]

hsv_img = cv2.cvtColor(res_img, cv2.COLOR_BGR2HSV_FULL)
mask = cv2.inRange(hsv_img, np.array(self.cfg['hero_step_define']['lower_gray_color']),
                            np.array(self.cfg['hero_step_define']['upper_gray_color']))
count_of_white_pixels = cv2.countNonZero(mask) Now that we've determined that it's our turn, we should recognize the hero’s cards and those on the table. To do this, I suggest that we again take advantage of the fact that the image is static and cut it out, and then binarize the areas with cards. As a result, for such images with cards: We get the following binary image: After that, we find the outer contours of the values and suits using function, which we then pass to function, which returns the bounding boxes of each contour. All right, now we have boxes of all the cards, but how do we know if we have, for example, an ace of hearts? To do this, I found and manually cropped each value and each suit, and placed these images in a special folder as reference images. Next, we calculate the MSE between each of the reference images and the cropped card images: findContours() boundingRect() err = np.sum((img.astype("float") - benchmark_img.astype("float")) ** 2)
err /= float(img.shape[0] * img.shape[1]) Which reference image has the smallest error, that is the name image we assign to the box. Quite easy :) Determining the bank and the player's bet: Finding the dealer button To determine the bank, we will work with a template image of this view: We pass the template image and the image of the whole table to the function, which I wrote about in one of my previous , which, as one of the parameters is to return the coordinates of the top-left corner of the template image on the image of the whole table. matchTemplate() articles Knowing these coordinates, we can, by stepping back a constant value to the right, find the digits of the bank. Then, according to the familiar scheme, we find the contours and boxes of each digit, which we subsequently compare with the reference, but already digits image, and count the MSE. All these machinations are described in this section, except for the search of template image, we also do the same with bets of each player, where the coordinates of bets are prescribed in the config file. The dealer button in poker is a mandatory attribute that determines the order of action and bargaining for all participants in the game. If you have to act one of the first, you are in the early position. If you are in a late position, your turn is one of the last to act. For the 6-max table, which is the table we're looking at, the positions are as follows: To determine who the dealer is, we also take a template image, only this one: We find the coordinates of the upper left corner of the image on the table and using the formula for the distance between two points on the plane, where the second x and y coordinates are prescribed in the configuration file coordinates of the player's center, determine who is closer to the button, that will be its owner :) Recognition of vacant seats and players who are absent It often happens that there are 5 players at the table instead of 6, so the empty seat is marked in this way: Under the nickname of a player who is currently absent, the following caption appears: To detect the presence of such players, we take these images as templates and the image of the table, and again give them as input to the function, but this time we don't return the coordinates, but the probability of how similar the two images are to each other. If the probability, for instance, between the first image and the table is high, then we have a table missing a player. matchTemplate() Calculating Equity Equity is the probability of winning a particular hand against two specific cards or the opponent's range. Mathematically, equity is calculated as the ratio of the number of possible winning combinations to the total number of possible combinations. In this algorithm can be implemented using library eval7 (which in this case helps to estimate how strong the hand is) as follows: Python deck = [eval7.Card(card) for card in deck]
table_cards = [eval7.Card(card) for card in table_cards]
hero_cards = [eval7.Card(card) for card in hero_cards]
max_table_cards = 5
win_count = 0
for _ in range(iters):
    np.random.shuffle(deck)
    num_remaining = max_table_cards - len(table_cards)
    draw = deck[:num_remaining+2]
    opp_hole, remaining_comm = draw[:2], draw[2:]
    player_hand = hero_cards + table_cards + remaining_comm
    opp_hand = opp_hole + table_cards + remaining_comm
    player_strength = eval7.evaluate(player_hand)
    opp_strength = eval7.evaluate(opp_hand)

    if player_strength > opp_strength:
        win_count += 1

win_prob = (win_count / iters) * 100 Conclusion In this article, I wanted to show what can be achieved using only classic computer vision methods. I understand that the current solution is unlikely to be used in poker games, but in the future, I plan to add analytics, which can already be useful. If anyone wants to participate in the project or has any ideas for its development - feel free to write! The source code is available on , as always. Have a nice day everyone! github Also published . here

Playing Poker with Computer Vision

So OPEN cv, HUH! Yes! Why Not!! Okay, then. Since working with images is becoming more and more popularized, we are going to take a dive into this field, going from the basics and starting with the OPEN CV library. Which lets us do all the stuff with the images that we can imagine. In today’s post, we will explore 2 functions of Open Cv: and ; which do what their name suggests. imread imshow is used to read an image, and is used to display the images using an open cv. imread imshow Let us first import the library we need. import opencv as cv2 Now, let us explore today’s jungle of open cv and find the meaning and working of two 👑s of this jungle. imread() So, this function is used to read an image, given the path of the image is correct 🤣. im = cv2.imread("path to the image") We must know that the image read - it is read in BGR color format and not the RGB format. Behind every image is a set of pixels, so if we print the , we will get the NumPy array. im If we want to display the image and not the array, we must use function and not the print function. nd imshow What it does is it reads the pixel values and displays those based on the color channel of the image. cv2.imshow("window name", image) is the array, and ‘window name’ is any arbitrary name for the window that pops up for the displaying of images. image numpy nd Conclusion So, this is how easy is it to read and then display images using an open cv. I hope you got an understanding of these concepts. Thank you for reading and See you in the next post

This Is How Easy it Is to Read and Display Images

In this article, I will be showing you how to create a Dapp that allows us to store data on the Arweave network, using bundlr on testnet. Before going forward, let’s see what are we going to build today. https://www.loom.com/share/808aff5aa5d84ead93c106cfb96ff05f?t=70 Here is the deployed link if you want to try it out: https://bundlr-arweave.netlify.app/ Tech Stack and Libraries I’ve Used: Nextjs Chakra UI RainbowKit Wagmi Bundlr Client Well, Well, Let’s Go Through What Is Arweave and Bundlr First (From the Doc). If you enjoy videos like me, here is a video for you: https://www.youtube.com/watch?v=DQbwiiXMtMo Arweave Arweave makes information permanence sustainable. Arweave is a new type of storage that backs data with sustainable and perpetual endowments, allowing users and developers to truly store data forever — for the very first time. Bundlr Bundlr makes web3 data storage on Arweave accessible by making it as fast, easy, and reliable as traditional data storage. Arweave is the only truly decentralized, permanent data storage solution. Bundlr increases the number of transactions conducted on Arweave by 4,000% without sacrificing security or usability and is around ~3,000x faster at uploading data. Bundlr currently accounts for over 90% of data uploaded to Arweave. It enables infinite scalability and enables instant and guaranteed transaction finality. It is a multichain solution and is compatible with leading blockchains including Ethereum, Solana, Avalanche, Polygon, and many more. Steps We Have to Follow to Upload to Arweave using Bundlr Connect wallet Initialize the Bundlr client Add funds ($BNDLR tokens) Upload the files we will be bulding this app on polygon mumbai testnet. Bundlr has a devnet which allows you to use devnet/testnet cryptocurrency networks to pay for storage. The devnet node behaves exactly as a mainnet node - other than data is never moved to Arweave and will be cleared from Bundlr after a week. Note: Let's Get Building Keep the completed code open on the side for a better understanding . Github 1. Setting up the project Setup a Nextjs project with tailwind CSS and Chakra UIYou can use package to get done with setup quickly or just clone this Also, install these two dependencies create-web3-frontend . project repo yarn add @bundlr-network/client bignumber.js 2. Connect wallet As we are using Rainbow kit this step is very easy in index.tsx const Home: NextPage = () => {
  const { data } = useAccount();
  if (!data) {
    return (
      <div className='justify-center items-center h-screen flex '>
        <VStack gap={8}>
          <Text className='text-4xl font-bold'>
            Connect your wallet first
          </Text>
          <ConnectButton />
        </VStack>
      </div>
    )
  }

  if (activeChain && activeChain.id !== chainId.polygonMumbai) {
    return (
      <div className='justify-center items-center h-screen flex '>
        <VStack gap={8}>
          <Text className='text-4xl font-bold'>
            Opps, wrong network!! Switch to Polygon Mumbai Testnet
          </Text>
          <ConnectButton />
        </VStack>
      </div>
    )
  }
} And with these 5–6 lines of code, we are done with connecting the wallet 🎉 We have also added a condition to check if a user is on the Mumbai test, as we will be using polygon Mumbai testnet for this article. In while configuring Rainbow kit we have configures it for using polygon Mumbai testnet _app.jsx const { chains, provider } = configureChains(
  [chain.polygonMumbai],
  [
    jsonRpcProvider({ rpc: () => ({ http: process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL }) }),
    publicProvider(),
  ]
); So, Rainbow kit will also take care of changing the network for us, this is how this warning will look like 3. Initializing the Bundlr Let’s create a context for bundlr, so we can maintain all bundlr related logic form there. Create . Inside this file let's create the context now, you can see the completed version of the file bundlr.context.tsx here import { WebBundlr } from '@bundlr-network/client';
import { useToast } from '@chakra-ui/react';
import BigNumber from 'bignumber.js';
import { providers, utils } from 'ethers';
import React, { createContext, useContext, useEffect, useState } from 'react'

const BundlrContext = createContext<IBundlrHook>({
    initialiseBundlr: async () => { },
    fundWallet: (_: number) => { },
    balance: '',
    uploadFile: async (_file) => { },
    bundlrInstance: null
});

const BundlrContextProvider = ({ children }: any): JSX.Element => {
    const toast = useToast()
    const [bundlrInstance, setBundlrInstance] = useState<WebBundlr>();
    const [balance, setBalance] = useState<string>('');

    useEffect(() => {
        if (bundlrInstance) {
            fetchBalance();
        }
    }, [bundlrInstance])

    const initialiseBundlr = async () => {
        const provider = new providers.Web3Provider(window.ethereum as any);
        await provider._ready();
        const bundlr = new WebBundlr(
            "https://devnet.bundlr.network",
            "matic",
            provider,
            {
                providerUrl:
                    process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL,
            }
        );
        await bundlr.ready();
        setBundlrInstance(bundlr);
    }

    async function fundWallet(amount: number) {
        try {
            if (bundlrInstance) {
                if (!amount) return
                const amountParsed = parseInput(amount)
                if (amountParsed) {
                    toast({
                        title: "Adding funds please wait",
                        status: "loading"
                    })
                    let response = await bundlrInstance.fund(amountParsed)
                    console.log('Wallet funded: ', response)
                    toast({
                        title: "Funds added",
                        status: "success"
                    })
                }
                fetchBalance()
            }
        } catch (error) {
            console.log("error", error);
            toast({
                title: error.message || "Something went wrong!",
                status: "error"
            })
        }
    }

    function parseInput(input: number) {
        const conv = new BigNumber(input).multipliedBy(bundlrInstance!.currencyConfig.base[1])
        if (conv.isLessThan(1)) {
            console.log('error: value too small')
            toast({
                title: "Error: value too small",
                status: "error"
            })
            return
        } else {
            return conv
        }
    }

    async function fetchBalance() {
        if (bundlrInstance) {
            const bal = await bundlrInstance.getLoadedBalance();
            console.log("bal: ", utils.formatEther(bal.toString()));
            setBalance(utils.formatEther(bal.toString()));
        }
    }

    async function uploadFile(file) {
        try {
            let tx = await bundlrInstance.uploader.upload(file, [{ name: "Content-Type", value: "image/png" }])
            return tx;
        } catch (error) {
            toast({
                title: error.message || "Something went wrong!",
                status: "error"
            })
        }
    }

    return (
        <BundlrContext.Provider value={{ initialiseBundlr, fundWallet, balance, uploadFile, bundlrInstance }}>
            {children}
        </BundlrContext.Provider>
    )
}

export default BundlrContextProvider;

export const useBundler = () => {
    return useContext(BundlrContext);
} For initializing the Bundlr we will be using the method from the code above initialiseBundlr and the code is also pretty straightforward const bundlr = new WebBundlr(
            "https://devnet.bundlr.network",
            "matic",
            provider,
            {
                providerUrl:
                    process.env.NEXT_PUBLIC_ALCHEMY_RPC_URL,
            }
        );
        await bundlr.ready();
        setBundlrInstance(bundlr); We are creating an instance of the Bundlr client and storing it in a state variable. Read more about For using Bundlr with testnet . bundlr client read here In order to use the devnet, you need to use as the node and set the provider url to a correct testnet/devnet RPC endpoint for the given chain. https://devnet.bundlr.network Our, RPC URL will look something like this, as we will be using polygon testnet NEXT_PUBLIC_ALCHEMY_RPC_URL=https://polygon-mumbai.g.alchemy.com/v2/{{alchemy_project_id}} Read, about all the supported . currencies/ networks by bundlr here 4. Add funds ($BNDLR tokens) 💸 We already have data about our in the bundlr context, and we also have a method which we will be using to add the funds. Adding funds is also pretty straightforward, just use the method on the bundlrInstance and pass the amount you want to fund the wallet with balance fundWallet fund let response = await bundlrInstance.fund(amountParsed) In , make these changes index.tsx const Home: NextPage = () => {
    const { initialiseBundlr, bundlrInstance, balance } = useBundler();
    ...

    // at last
    if (!balance || Number(balance) <= 0) {
        return (
          <div className='justify-center items-center h-screen flex '>
            <VStack gap={8}>
              <ConnectButton />
              <Text className='text-4xl font-bold'>
                Opps, out of funds!, let's add some
              </Text>
              <FundWallet />
            </VStack>
          </div>
        )
      }
} Now let’s create the component. Create <FundWallet /> components/FundWallet.tsx import React from 'react'
import { Button, NumberDecrementStepper, NumberIncrementStepper, NumberInput, NumberInputField, NumberInputStepper, Text, VStack } from '@chakra-ui/react'
import { useBundler } from '@/state/bundlr.context';

const FundWallet = () => {
    const { fundWallet, balance } = useBundler();
    const [value, setValue] = React.useState('0.02')

    return (
        <div className='mt-12'>
            <VStack gap={6}>
                <Text fontSize={'xl'}>
                    Your current balace is: {balance || 0} $BNDLR
                </Text>
                <NumberInput className='mx-auto' step={0.01} defaultValue={value}
                    onChange={(valueString) => setValue(valueString)}
                >
                    <NumberInputField />
                    <NumberInputStepper >
                        <NumberIncrementStepper />
                        <NumberDecrementStepper />
                    </NumberInputStepper>
                </NumberInput>

                <Button onClick={() => fundWallet(+value)}>💸 Add Fund</Button>
            </VStack>
        </div>
    )
}

export default FundWallet 5. Upload images 📷 Now, as we’ve already added the funds, now we can upload the images (or any other files), to the Arweave network. In , add the following code at the end of the file index.tsx return (
    <div className='justify-center items-center h-screen flex'>
      <Stack direction={['column', 'row']} justifyContent={'space-around'} width={'full'} alignItems={'center'}>
        <VStack gap={8}>
          <ConnectButton />
          <FundWallet />
        </VStack>
        <VStack gap={8}>
          <Text fontSize={'4xl'}>
            Select Image To Upload
          </Text>
          <UploadImage />
        </VStack>
      </Stack>
    </div>
  ); Now, let’s create the component <UploadImage /> import React from 'react'
import { Box, Button, Text } from '@chakra-ui/react';
import { useBundler } from '@/state/bundlr.context';
import { useRef, useState } from 'react';

const UploadImage = () => {
    const { uploadFile } = useBundler();
    const [URI, setURI] = useState('')
    const [file, setFile] = useState<Buffer>()
    const [image, setImage] = useState('')
    const hiddenFileInput = useRef(null);

    function onFileChange(e: any) {
        const file = e.target.files[0]
        if (file) {
            const image = URL.createObjectURL(file)
            setImage(image)
            let reader = new FileReader()
            reader.onload = function () {
                if (reader.result) {
                    setFile(Buffer.from(reader.result as any))
                }
            }
            reader.readAsArrayBuffer(file)
        }
    }

    const handleClick = event => {
        hiddenFileInput.current.click();
    };

    const handleUpload = async () => {
        const res = await uploadFile(file);
        setURI(`http://arweave.net/${res.data.id}`)
    }

    return (
        <div className='flex flex-col mt-20 justify-center items-center w-full'>
            <Button onClick={handleClick} className='mb-4'>
                {image ? 'Change Selection' : 'Select Image'}
            </Button>
            <input
                accept="image/png, image/gif, image/jpeg"
                type="file"
                ref={hiddenFileInput}
                onChange={onFileChange}
                style={{ display: 'none' }}
            />

            {
                image &&
                <Box
                    display='flex'
                    alignItems='center'
                    justifyContent='center'
                    width='100%'
                    py={40}
                    bgImage={`url('${image}')`}
                    bgPosition='center'
                    bgRepeat='no-repeat'
                    mb={2}
                >
                    <button className='bg-gray-200 rounded px-8 py-2 text-black hover:bg-gray-100' onClick={handleUpload}>Upload File</button>
                </Box>
            }

            {
                URI && <Text className='mt-4'>
                    <Text fontSize='xl'> Uploaded File:</Text> <a href={URI} target="_blank">{URI}</a>
                </Text>
            }
        </div>
    )
}

export default UploadImage And, with this in place, we can now upload the files to the Arweave network 🚀 Further Improvement: Right now we are only uploading images, we can add support for other formats as well (video, audio, anything) Store URLs of uploaded images with wallet address in Supabase and show the list of files previously uploaded by users when they connect their wallet Completed code: GitHub Also published . here

Permanent File Storage for Web3 Apps With Arweave, Bundlr, Next.js, RainbowKit, and Wagmi

The Xbox 360 left a massive impression on the gaming industry. Selling , it was one of Microsoft’s most notable and successful endeavors in providing entertainment to the masses. And, as one might expect, the best Xbox 360 games shared in the console’s success quite heavily. over 80 million units by 2021 The games that performed best on the Xbox 360, however, are quite odd. In a way, the best-selling Xbox 360 games are opposite to - ironic, since both consoles were competing against each other at the time. This list is mainly populated with third-party titles, but the top-seller is an exclusive…and it’s one very few people might expect. the best-selling PS3 games The 10 Best Xbox 360 Games Ranked by Copies Sold 10. Grand Theft Auto IV 9. Halo 3 8. Call of Duty: Modern Warfare 2 7 & 6. The Elder Scrolls V: Skyrim and Call of Duty: Black Ops II 5. Call of Duty: Black Ops 4. Call of Duty: Modern Warfare 3 3. Minecraft 2. Grand Theft Auto V 1. Kinect Adventures! 10. Grand Theft Auto IV - 11.1 Million Copies Sold Grand Theft Auto IV was a major step forward in the GTA franchise. Noted as the first game in the “ ”, it featured updated controls, graphics, and mechanics, as well as a new story surrounding Niko Bellic, a man looking for a new life in America. While its sequel seems to have surpassed this title in popularity, GTA IV’s success still stands, kicking off this list and forever staying as a notable part of the Xbox 360’s history. HD Universe 9. Halo 3 - 12.13 Million Copies Sold Being perhaps one of the most well-known franchises of all, it’s no surprise Halo 3 makes it onto this list. It offered an intensive single-player campaign alongside vast new multiplayer experiences, such as the ability to create custom maps. The additions brought on by Halo 3 influenced the series in more ways than one, making it one of the most beloved Xbox 360 games out there - and perhaps . the best-selling Halo game so far 8. Call of Duty: Modern Warfare 2 - 13.49 Million Copies Sold For a franchise , Call of Duty shows up quite a few times on this list. Modern Warfare 2, while not particularly innovative or game-changing, still brought a large amount of attention to itself for its improvements and continued story. It’s also the source of , generating large controversy around the title. Despite this, the game was an absolute hit, even taking a spot on Metacritic's . almost as well-known as Mario and Pokemon the infamous “No Russian” scene top 100 games of all time 7 & 6. The Elder Scrolls V: Skyrim and Call of Duty: Black Ops II - 13.7 Copies Sold While the numbers for these two games might not be exact, they’re close enough to tie for the sake of this list. The Elder Scrolls V: Skyrim is one of the most well-known titles in all of gaming. It might be one of the best Xbox 360 games out there, if not one of the best games of all time. Skyrim gave fans of The Elder Scrolls a brand-new world to explore and battle through, featuring a protagonist that battles dragons to unlock incredible powers. Skyrim’s success went beyond the Xbox 360, releasing on practically every modern console to this date. Call of Duty: Black Ops II also went above and beyond, featuring a brand-new story with branching paths and a competitive mode for multiplayer. Activision marketed the game as having “ ”, something they intended to follow through on. This desire for innovation certainly helped, with Black Ops II’s total sales surpassing , and the Xbox 360 version taking a good chunk of that. disruptful innovation 20 million total 5. Call of Duty: Black Ops - 14.55 Million Copies Sold While Black Ops II managed to do well, its predecessor - Call of Duty: Black Ops - edged it out in total sales. Though perhaps not as technically impressive, it left a much deeper mark on fans with its returning features and unique story. It also brought back the Zombies mode, which would become a staple of practically every future Call of Duty game. Between its numerous sequels and its , it would be wrong to say Black Ops wasn’t a massive success. incredible earnings 4. Call of Duty: Modern Warfare 3 - 14.72 Million Copies Sold The final Call of Duty game on this list, Call of Duty: Modern Warfare 3 managed to surpass Black ops as the best-selling title in the franchise. While , that success wasn’t for nothing. Between a revamp of Modern Warfare 2’s systems, a continuation of its story, and brand new game modes, Modern Warfare 3 is perhaps one of the finest examples of Call of Duty’s overwhelming success. it might not hold this distinction anymore 3. Minecraft - 21+ Million Copies Sold Minecraft is a game that needs no introduction. While mainly a PC title, the first console it was ported to was the Xbox 360, offering a unique experience while also expanding its audience. The success of the 360 version of Minecraft is possibly the catalyst that led to Microsoft’s , an act that led to the game reaching even greater heights. Even with its stripped-back features, people found a very faithful and newcomer-friendly experience on consoles; for a time, Minecraft might have been the best Xbox 360-exclusive game out there. purchase of the game’s rights 2. Grand Theft Auto V - 22.95 Million Copies Sold Of course, Grand Theft Auto V had to be somewhere on this list. Having sold , and with the Xbox 360 version releasing alongside the PS3 version, this title’s incredible performance was guaranteed. It might not be the best-selling Xbox 360 game of all time, but depending on who you ask, maybe it should be held in that regard anyway. over 150 million copies total 1. Kinect Adventures! - 24 Million Copies Sold That’s right - the most successful Xbox 360 title is Kinect Adventures!. While it might seem like a shock to most, it makes sense when you consider it was bundled with Xbox consoles that came with the Kinect add-on. As such, its success is more comparable to something like - it’s likely not many people were getting their hands on it on purpose. Even so, Kinect Adventures offered multiple game modes and even online multiplayer; people might not agree on whether or not it deserved such success, but it wasn’t entirely unwarranted. Wii Sports As previously mentioned, this list contrasts the list of best-selling PS3 games. While the most successful titles on the PS3 were exclusives, only one game on the Xbox 360’s top 10 wasn’t even released on another platform. While some might see this as a disappointment, it’s honestly impressive - the PS3 was successful partially due to its exclusives, while the Xbox 360 was successful despite its best-sellers not being exclusives. The appeal of the 360 was universal, and it’s certain to be remembered as one of the most beloved consoles of all time. Fans of Microsoft’s consoles should also check out . the top 10 best-selling original Xbox games Sources: Microsoft says Xbox 360 sales have surpassed 76 million units, Kinect sales top 24 million (bgr.com) This violent videogame has made more money than any movie ever - MarketWatch (archive.org) 4J Studios on Twitter: "TU73 (the final update) for Minecraft: Xbox 360 Edition will be out later today, adding The Nightmare Before Christmas Mash-up Pack. It's been a long journey since TU1 on May 9, 2012! Thank you to the more than 21 million #MinecraftX360 players for your support over the years :)" / Twitter Best selling Xbox 360 games of all time | Windows Central Skyrim : The Elder Scrolls V Statistics - Statistic Brain

10 Best Xbox 360 Games of All Time Ranked by Sales

Anyone familiar with Deep Learning or any other similar buzz words is usually also familiar with Jupyter Notebooks. Unfortunately, many associate Machine/Deep Learning only with Jupyter Notebooks and nothing beyond that. However, in practice, Jupyter Notebook is a prototyping tool for model building, training, and experimentation. Deployment of the models is an essential part of being a Data Scientist since, irrespective of the achieved accuracies, models that cannot be deployed will hardly be of any practical use. The model deployment comes in many forms depending on the application. For example, if you are building a mobile app, you would likely want to use TensorFlow Lite or Pytorch Mobile to convert your models to an optimized format that can be integrated into the application. On the other hand, if you are building your applications for an edge device, then depending on the hardware, you may want to use TensorRT (for Jetson devices and Nvidia GPUs), OpenVINO (for Intel CPUs), or TensorFlow Lite (for Coral Edge TPU devices). In this writeup, we will explore a part of a deployment that deals with hosting the deep learning model to make it available across the web for inference, known as model servers. There are different kinds of open-source model servers developed by various open-source communities. A few popular ones are listed below: – official release by TensorFlow TensorFlow Serving – official release by Pytorch TorchServe – official release by Intel OpenVINO OpenVINO Model Server – official release by Nvidia Triton Inference Server (Formerly KFServing) – official release by Kubeflow (Kubernetes) KServe Exploring all of the above is beyond the scope of this article, so we will first learn how to build our own, and then explore the Triton Inference Server (by Nvidia), which is platform-independent and supports a wide variety of model formats. Since we are exploring a relatively advanced topic, there are certain prerequisites for this, and the same are listed below: Python – Everything we will be doing is based on Python TensorFlow – That is my preferred framework, but feel free to follow along with Pytorch Flask – You just need the flask “hello world” steps; pretty easy to learn OpenCV – In this example, we will be dealing with images Communication Protocols: REST API request-response and gRPC Before we dive into the hands-on section, let’s talk about what is all the fuss about. Fundamentally a model server is a web server that hosts the deep learning model and allows it to be accessed over standard network protocols. Functionally it is similar to a web server as well. You send a request to get back a response. Similarly, just like a web server, the model can be accessed across devices as long as they are connected via a common network. A high-level block diagram illustrating the same is shown below. As shown in the diagram, the primary advantage that a model server provides is its ability to “serve” multiple client requests simultaneously. This means that if multiple applications are using the same model to run inference, then a model server is the way to go. This extends to a second advantage, that is, since the same server is serving multiple client requests simultaneously, the model does not consume excessive CPU/GPU memory. The memory footprint roughly remains the same as that of a single model. Further, the model server can be hosted on a remote server (e.g., AWS, Azure, or GCP), or locally in the same physical system as your client(s). The inference latency would vary depending on the closeness of the server to the client(s) and the network bandwidth. Though a large number of simultaneous requests would slow down the inference speed significantly, in which case, multiple instances of the model server can be hosted, and the hosting hardware can be scaled up as a solution. But that is beyond the scope of this article. Now that the basics are out of the way, let’s dive into the hands-on part, shall we? I recommend that you use Linux for this tutorial. macOS and Windows should work fine, but no promises. I am using Ubuntu 20.04.3 LTS. - Installations & Versions – Feel free to skip this section if you are already a pro. Step 0 Python (v3.7.4): My recommendation: Miniconda – | Download Installation TensorFlow (v2.7.0): pip install tensorflow Flask (v2.0.2): pip install flask TritonClient (v2.6.0): pip install tritonclient[all] --extra-index-url https://pypi.ngc.nvidia.com OpenCV (v4.5.4.58): pip install opencv-python Docker (v20.10.11): (recommended) | | Linux Windows MacOS Matching the versions is not required. Feel free to install the latest version. They should probably work fine. In case they don’t, you have the versions for reference. Flask (Custom) Model Server - We need a model. So, let’s train one! Feel free to use any compatible model, it should work fine as long as it’s not overly complicated. Step 1 I will keep it simple and use the official , and save the model in format. Keras MNIST example TensorFlow SavedModel import os

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Model / data parameters
num_classes = 10
input_shape = (28, 28, 1)

# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Scale images to the [0, 1] range
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
# Make sure images have shape (28, 28, 1)
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
print("x_train shape:", x_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")


# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

model = keras.Sequential(
    [
        keras.Input(shape=input_shape, name="input_1"),
        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Flatten(),
        layers.Dropout(0.5),
        layers.Dense(num_classes, activation="softmax", name="output_1"),
    ]
)

model.summary()

batch_size = 128
epochs = 15

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])

model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)

score = model.evaluate(x_test, y_test, verbose=0)
print("Test loss:", score[0])
print("Test accuracy:", score[1])

tf.keras.models.save_model(model, "mnist_model") - Build an inference script and integrate it with Flask to host it as a server which will act as the “model server”. Step 2 As a next step, the model server can be hosted on a remote machine/server and the process is similar to deploying a web app. Though, keep in mind that the server should have enough computational resources for the smooth operations of the Deep Learning frameworks: Pytorch or Tensorflow, and hence, the free tier of Heroku likely will not make the cut. from flask import Flask, redirect, jsonify, request
import cv2, os, sys, imutils
import numpy as np
import tensorflow as tf

MODEL_PATH = 'mnist_model'

app = Flask(__name__)
app.config['DEBUG'] = False

# Load the Model
model = tf.keras.models.load_model(MODEL_PATH)

@app.route('/mnist_infer', methods=['POST'])
def hand_classifier():
    # Receive the encoded frame and convert it back to a Numpy Array
    encoded_image = np.frombuffer(request.data, np.uint8)
    image = cv2.imdecode(encoded_image, -1) # Decode image without converting to BGR
    
    image = np.expand_dims([image], axis=-1) # Add dimensions to create appropriate tensor shapes
    
    # Run inference on the frame
    hand = model.predict(image)

    return jsonify(str(np.argmax(hand))) # Because only string can be converted to JSON

if __name__ == '__main__':
    app.run(host='0.0.0.0', port='5000', threaded=True, use_reloader=False) - Build a client script to randomly pick images, send them to the model server for inference and process the predictions to calculate the accuracy. Step 3 This script is created just to represent how to run inference. However, instead of this script, in practice, it can be any device making the inference request call. For example, you can build an Android application that clicks an image with the camera and sends it to the model server hosted on the cloud (AWS, Azure, GCP, etc.) for inference. Once the predictions are received, you can then display the results on the Android app or perform further operations on the same. import cv2, random, requests
import numpy as np
from glob import glob
from tqdm import tqdm

TEST_MNIST_PATHS = glob("/media/ActiveTraining/WOBOT/data/MNIST Dataset JPG format/MNIST - JPG - testing/*/*.jpg")
MODEL_ENDPOINT = "http://0.0.0.0:5000/mnist_infer"
NUM_SAMPLES = 1000
INPUT_SHAPE = (28, 28)

# Choose random images from the test set
path_choices = random.choices(TEST_MNIST_PATHS, k=NUM_SAMPLES)


def preprocess_image(image):
    image = cv2.resize(image, INPUT_SHAPE) # This step is not strictly required for MNIST
    image = image / 255 # Normalize Image
    return image

accuracy = list()

# Loop though each image and run inference
for test_mnist_path in tqdm(path_choices):
    label = int(test_mnist_path.split("/")[-2]) # Get the label
    image = cv2.imread(test_mnist_path, -1) # Read image without converting to BGR
    image = preprocess_image(image) # Preprocess the image
    
    # Encode the image as JPG and Send to the Model Server
    _, img_encoded = cv2.imencode('.jpg', image)
    response = requests.post(MODEL_ENDPOINT, data=img_encoded.tobytes())
    pred = int(response.json()) # Decode the response to get the predictions

    accuracy.append(pred == label)

print(f"Testing Accuracy: {np.mean(accuracy)*100:.2f}%") - Keep experimenting to get a thorough understanding of the inner workings of what is happening here. Step 4 Triton Inference Server Now that we have built our own model server and ran inference, we can move on to the next step, where we use a pre-built and a much more optimized model server as provided by Nvidia themselves: the Triton Inference Server. Before we move on to the hands-on section, I recommend you go through the beautiful block diagram provided by Nvidia. Now, moving on to the hands-on section, we will use gRPC and Docker. Both require their own introductory article and hence are beyond the scope of this article. For simplicity: Think of it as a communication protocol developed by Google which is more efficient than a REST API call and is based on web RPC. For a further read, I would recommend: by Miguel Ratia and by Janakiram MSV. gRPC: What is gRPC? Google’s gRPC: A Lean and Mean Communication Protocol for Microservices This is much easier to grasp – think of it like a secluded virtual environment where you can do whatever you want without affecting your host device (mostly). You can also just download an existing environment and run it without any additional setups (pretty much what we are about to do). For a detailed read: by IBM, and – Nothing beats this, one of the best-documented products (my opinion). Docker: What is Docker Official Docker Documentation - This will require additional steps and model conversions before moving to the next step. You can choose to convert the Pytorch model to or and use follow the specific directions as mentioned in the . Step 1 (Pytorch) TorchScript ONNX Triton Server Model Repository readme - We skip installations (since it’s already done), and move on to a specific directory structure required by the Triton Server. Step 1 (Tensorflow) Move the SavedModel contents to . The detailed instructions can be found in the official readme provided by Nvidia. In summary, the new directory structure should look something like this (The files are the python scripts discussed in this article): <model-name>/1/model.savedmodel/<SavedModel-contents> .py .
├── mnist_model
│   ├── 1
│   │   └── model.savedmodel
│   │       ├── assets
│   │       ├── keras_metadata.pb
│   │       ├── saved_model.pb
│   │       └── variables
│   │           ├── variables.data-00000-of-00001
│   │           └── variables.index
├── flask_client.py
├── flask_server.py
├── train_mnist.py
└── triton_client.py - Pull the required Triton Server Docker image and run the container using the following command: Step 2 docker run --gpus=all --rm -it -p 8000-8002:8000-8002 --name triton_server -v $PWD:/models nvcr.io/nvidia/tritonserver:21.02-py3 tritonserver --model-repository=/models --strict-model-config=false In this command, use the flag only if you have a GPU and have installed. Else skip it if you want to run CPU inference (slower). --gpus=all nvidia-docker Use the (optional) flag if you want the container to be deleted once you stop the server --rm Use the (optional) flag to view the container logs and stop them using keyboard interrupt ( ) --it Ctrl+C Use the flag to map the ports from inside the container to your host system. Without this, the inference will not take place since the program on the host system will not have access to the port inside the container. --p Use (optional) to identify the container with a chosen name. Otherwise, a random one will automatically be assigned. --name Use to mount the volumes into the container. Here points to the current directory, assuming your model is located in the same directory. -v $PWD The docker image name is: nvcr.io/nvidia/tritonserver:21.02-py3 points to the directory containing the model name and the files inside it. (Directory structure is very important) --model-repository=/models : This flag allows the Triton Server to auto-configure for the given model. Alternatively, a specific can be created to specify the config. But that is again beyond the scope of this article, and more information can be found here: . strict-model-config=false config.pbtxt Triton Model Configuration Readme - Verify if your model is loaded properly or not. Step 3 Once the model is loaded successfully, you should see the same printed in the docker logs and the status for the given model should be “READY”. Another way to verify the model is to use the REST API to verify the config. If you have followed all instructions properly, then you should find the JSON model config by visiting on your browser. The general format for this URL is: . http://localhost:8000/v2/models/mnist_model/config http://<host-ip-address>:<mapped-http-port>/v2/models/<model-name>/config - Triton Inference Client Script with gRPC – This is again similar to the previous client script that we had created for the Flask Model Server. Step 4 import cv2, random
import numpy as np
from glob import glob
from tqdm import tqdm
import tritonclient.grpc as grpcclient

# GLOBAL VARIABLES
TEST_MNIST_PATHS = glob("/media/ActiveTraining/WOBOT/data/MNIST Dataset JPG format/MNIST - JPG - testing/*/*.jpg")
NUM_SAMPLES = 1000
INPUT_SHAPE = (28, 28)

# Triton Variables
TRITON_IP = "localhost"
TRITON_PORT = 8001
MODEL_NAME = "mnist_model"
INPUTS = []
OUTPUTS = []
INPUT_LAYER_NAME = "input_1"
OUTPUT_LAYER_NAME = "output_1"

# Choose random images from the test set
path_choices = random.choices(TEST_MNIST_PATHS, k=NUM_SAMPLES)


def preprocess_image(image):
    image = cv2.resize(image, INPUT_SHAPE) # This step is not strictly required for MNIST
    image = image / 255 # Normalize Image
    image = np.expand_dims([image], axis=-1) # Increase the dimensions to match that of the model
    return image.astype(np.float32)

def postprocess_output(preds):
    return np.argmax(np.squeeze(preds))

accuracy = list()

# Triton Initializations
INPUTS.append(grpcclient.InferInput(INPUT_LAYER_NAME, [1, INPUT_SHAPE[0], INPUT_SHAPE[1], 1], "FP32"))
OUTPUTS.append(grpcclient.InferRequestedOutput(OUTPUT_LAYER_NAME))
TRITON_CLIENT = grpcclient.InferenceServerClient(url=f"{TRITON_IP}:{TRITON_PORT}")

# Loop though each image and run inference
for test_mnist_path in tqdm(path_choices):
    label = int(test_mnist_path.split("/")[-2]) # Get the label
    image = cv2.imread(test_mnist_path, -1) # Read image without converting to BGR
    image = preprocess_image(image) # Preprocess the image

    # Run the Inference using the gRPC triton client
    INPUTS[0].set_data_from_numpy(image) # Set the Inputs
    result = TRITON_CLIENT.infer(model_name=MODEL_NAME, inputs=INPUTS, outputs=OUTPUTS, headers={}) # Run Inference
    output = np.squeeze(result.as_numpy(OUTPUT_LAYER_NAME)) # Process the Outputs
    pred = postprocess_output(output) # Postprocess (Argmax)

    # Record Accuracy
    accuracy.append(pred == label) 

print(f"Testing Accuracy: {np.mean(accuracy)*100:.2f}%") - Again, keep experimenting, and I do encourage trying with different models. Step 5 And we are done! Congratulations on taking the first step towards model deployment! And trust me, you still have a long way to go! This is just the tip of the iceberg 😃 Feel free to try out the other model servers that are also available. Each has its own strengths and weaknesses which you will come to learn once you start using them.

Deploying Deep Learning Models with Model Server

Why Build? As we already know the whole world is suffering from COVID-19 and the vaccinations are going in full swing everywhere. Finding a slot is getting tougher in our country India as we have a huge population to be vaccinated. Numerous times we have to go to to search for a slot and slots are always full. It is pretty time-consuming and irritating. Being a developer, I thought most of the time is usually spent by us in the terminal so why can't we have a basic terminal-based app to save time. So this post will help you in two ways CoWin site Learn how to create Node.js based CLI's Get real-time info about vaccination slots for your area. In case you are someone who likes to watch than read you can watch the same Let's begin our initial setup! – We are assuming you have installed Node.js and npm, If not you can install from Pre-requisite here So as a first step lets initialize our project using command npm init Enter the basic details as shown below. This will create package.json file in the folder cowinCLI. The next step is to create a bin folder that will have our index.js file containing our application. Open the index.js file and add the below-mentioned first line. This actually tells the interpreter that whatever code runs below this will be handled by the node. #! /usr/bin/env node If you remember while creating we have mentioned our entry point as index.js but actually, this file now exists in the bin folder. So we will correct that as well as we will add one more entry. The new entry which we will add is for the keyword we want to use to call our CLI. We want to use something like cowin. So we will add this entry. : { : } "bin" "cowin" "./bin/index.js" So your package.json will look something like this { : , : , : , : , : { : }, : , : , : { : , : , : , : , : , : }, : { : }
} "name" "vaccli" "version" "1.0.0" "description" "CLI vaccination slots" "main" "bin/index.js" "scripts" "test" "echo \"Error: no test specified\" && exit 1" "author" "Nabheet" "license" "ISC" "dependencies" "axios" "^0.21.1" "chalk" "^4.1.1" "commander" "^7.2.0" "inquirer" "^8.0.0" "node-notifier" "^9.0.1" "tty-table" "^4.1.3" "bin" "cowin" "./bin/index.js" So the basic structure is set. Now before we start adding the functionality we have not given a thought to how we will fetch the data? Let's first check that. Do we have an API to fetch covid vaccination slots data? Thank God for looking at site they have provided us with . 50% of work is done. Now, all we need to do is, consume this data and work as per our need. Let's now think about what our CLI will do. Co-Win OpenAPI What functions our CLI will perform? On looking closely at the for a district( In India we have a Country comprised of States and Union Territories which in turn consists of districts) we can see it needs some kind of district id. calendar slots api So looking at how do we get districts id we found another but that needs state id api How do we get state id's another 😊 API So our CLI shall do the following. Ability to get all states and id's Ability to get all district id's for a state id Ability to get slots by district id Ability to filter slots by ages as we have slots by 18-45 and 45 and above. Apart from this some beautification Desktop notification In order to achieve this, we will be using multiple modules lets install them first using the below-mentioned command npm npm install axios chalk commander inquirer node-notifier tty-table Packages to be installed Axios –for calling the different API's Chalk – for beautifying the console output Commander – giving the different options and command in CLI such as cowin states or cowin districts <state id>; Inquirer – for getting user input for entering the age filter Node-notifier – send desktop notification Tty-table – format our table output Let's begin by creating separate functions for them. Create a util folder under the cowinCLI project. Create files states.js, districts.js, config.js, and slots.js in util folder. Config.js is for the configuration related common data such as table header formatting which will be used by all functions exports.config = { : { : },
};
exports.options = { : , : , : , : , : , : , : ,
}; // Common configuration data to be used by all functions. headers "User-Agent" "Axios - console app" borderStyle "solid" borderColor "blue" headerAlign "center" align "left" color "white" truncate "..." width "90%" Let's first code our reusable States function in states.js If you look, we need to call the states for that we will use our already installed npm package . We are calling the API and once we got a response we are formatting the table data by using the tty-table package and writing the output to the console. So this function will return the formatted output of states and its id's. API axios axios = ( ); table = ( ); { config,options } = ( ); .exports = {
    axios
    .get( , config)
    .then( { header = [
        { : , : , : , : , : , : ,
        },
        { : , : , : , : , : , : ,
        },
      ]; out = table(header, response.data.states, options).render(); .table(out);
    })
    .catch( { .log(error);
    });
}; const require 'axios' const require "tty-table" const require './config' // function to return list of all states module ( ) function "https://cdn-api.co-vin.in/api/v2/admin/location/states" ( ) => response // table formatter let value "state_id" headerColor "cyan" alias "State ID" color "white" align "left" width 40 value "state_name" alias "State" headerColor "cyan" color "white" align "left" width 40 const console ( ) => error console Let's code our second reusable Districts function in districts.js For this also we will use a similar set up of axios and tty-table. The only thing to be noted is, in this function which we are exporting has an argument as stateid. axios = ( ); table = ( ); { config,options } = ( ); .exports = {
    axios
    .get( ,
      config
    )
    .then( { header = [
        { : , : , : , : , : , : ,
        },
        { : , : , : , : , : , : ,
        },
      ]; out = table(header, response.data.districts, options).render(); .table(out);
    })
    .catch( { .log(error);
    });
}; const require 'axios' const require "tty-table" const require './config' // Function which take stateid as input and return all the formatted districts module ( ) function stateid `https://cdn-api.co-vin.in/api/v2/admin/location/districts/ ` ${stateid} ( ) => response // Table header specific formatting let value "district_id" headerColor "cyan" alias "District ID" color "white" align "left" width 40 value "district_name" alias "District" headerColor "cyan" color "white" align "left" width 40 // Output the results. const console ( ) => error console Let's code our third reusable slots function in slots.js For this also we will use a similar set up of axios and tty-table. The only thing to be noted is in this function which we are exporting has an argument as districtid. In addition to it you can see we are using chalk and inquirer package. Chalk is used to format the headers above the table and inquirer is used for taking input from user when slots command is run. We have also used node-notifier which will send desktop notification as soon as it runs, just an example. You can modify this behavior to code your own custom logic. axios = ( ); table = ( ); chalk = ( ); notifier = ( ); inquirer = ( ); { config,options } = ( ); .exports = { inquirer
    .prompt([
      { : , : , : , : [
          { : , : ,
          },
          { : , : ,
          },
          { : , : ,
          },
        ],
      },
    ])
    .then( { date = (); todaysDate = ; .log(
        chalk.underline.bgRed.bold( )
      );
      
      axios
        .get( ,
          config
        )
        .then( { finalData = []; districtName;

          response.data.centers.forEach( {
            item.sessions.forEach( {
              districtName = item.district_name; (answers.choice == ) { data = { : item.name, : item.address, : session.date, : session.available_capacity, : session.min_age_limit,
                };
                finalData.push(data);
              } (
                answers.choice == &&
                session.min_age_limit == ) { data = { : item.name, : item.address, : session.date, : session.available_capacity, : session.min_age_limit,
                };
                finalData.push(data);
              } (
                answers.choice == &&
                session.min_age_limit == ) { data = { : item.name, : item.address, : session.date, : session.available_capacity, : session.min_age_limit,
                };
                finalData.push(data);
              }
            });
          }); .log(
            chalk.underline.bgGreen.bold( )
          ); (answers.choice) { : .log(chalk.underline.bgBlue.bold( )); ; : .log(chalk.underline.bgBlue.bold( )); ; : .log(chalk.underline.bgBlue.bold( )); ; : ;
          } header = [
            { : , : , : , : , : ,
            },
            { : , : , : , : , : ,
            },
            { : , : , : , : , : ,
            },
            { : , : , : , : , : ,
            },
            { : , : , : , : , : ,
            },
          ]; out = table(header, finalData, options).render(); .table(out);
          notifier.notify({ : , : , : , : ,
          });
        })
        .catch( { .log(error);
        });
    })
    .catch( { (error.isTtyError) { } { }
    });
}; const require 'axios' const require "tty-table" const require "chalk" const require "node-notifier" var require "inquirer" const require './config' // function to check slots. module ( ) function district //Input prompt for getting what age you want to check records. type "list" name "choice" message "Which Age group?" choices name "View All" value "" name "45 Plus" value "45" name "18 - 45 " value "18" ( ) => answers const new Date var ` - - ` ${date.getDate()} ${ (
        date.getMonth() + ).padStart( , )} String 1 2 "0" ${date.getFullYear()} console `Showing Slots from - ` ${todaysDate} `https://cdn-api.co-vin.in/api/v2/appointment/sessions/public/calendarByDistrict?district_id= &date= ` ${district} ${todaysDate} ( ) => response let let ( ) => item ( ) => session // based on user age choice filter the data if "" let Center Address Date FreeSlots Age else if "18" "18" let Center Address Date FreeSlots Age else if "45" "45" let Center Address Date FreeSlots Age console `District - ` ${districtName} switch case "" console `All ages` break case "45" console `45+ Age` break case "18" console `18-45 Age` break default break // table formatting let value "Center" headerColor "cyan" color "white" align "left" width 40 value "Address" headerColor "cyan" color "white" align "left" width 40 value "Date" headerColor "cyan" color "white" align "left" width 15 value "FreeSlots" headerColor "cyan" color "white" align "left" width 20 value "Age" headerColor "cyan" color "white" align "left" width 20 const console title "Vaccination Slots Available" subtitle "Daily Maintenance" message "Immediately go and check Vaccination slots!" wait true ( ) => error console ( ) => error if // Prompt couldn't be rendered in the current environment else // Something else went wrong Now our all basic functions are in place but what is pending is the actual CLI😊 Let's start building that. Lets now build the CLI by updating index.js So far we have used all npm packages except commander it is the heart of our CLI. We will be using commander for making the subcommands as well as flag options. As can be seen, below we have used both command and option. Commands for getting states, districts, and slots and they have a callback function mentioned as our reusable functions under action. program = ( ); districts = ( ); states = ( ); slots = ( ); program.option( , );
program
  .command( )
  .description( )
  .action(states);
program
  .command( )
  .description( )
  .action(districts);

program
  .command( )
  .description( )
  .action(slots);

program.parse(); #! /usr/bin/env node const require "commander" // import all functions const require '../util/districts' const require '../util/states' const require '../util/slots' // adding different cli options,commands and passing callback functions in actions "-a, --available" "Output If slots available" "states" "Get all State Codes and descriptions." "district <stateid>" "Get all district of a State" "slots <districtid>" "Get slots for the district" Final touches So we have everything ready all we need to do is now run the below command which will install our package globally. npm install -g . Output cowin states cowin districts 12 cowin slots 187 You can refer to the source code Previously published at https://blogs.sap.com/2021/05/15/lets-build-node.js-based-cli-track-real-time-covid-19-vaccination-slots-in-india/?update=updated

Building A Node.js Based CLI For Real-Time COVID-19 Vaccination Tracking

Breast cancer is the most common form of cancer in women, and invasive ductal carcinoma (IDC) is the most common form of breast cancer. Accurately identifying and categorizing breast cancer subtypes is an important clinical task, and automated methods can be used to save time and reduce errors. The goal of this article is to identify IDC when it is present in otherwise unlabeled histopathology images. The consists of 277,524 50x50 pixel RGB digital image patches that were derived from 162 H&E-stained breast histopathology samples. These images are small patches that were extracted from digital images of breast tissue samples. dataset The breast tissue contains many cells but only some of them are cancerous. Patches that are labeled “1” contain cells that are characteristic of invasive ductal carcinoma. For more information about the data, see and . https://www.ncbi.nlm.nih.gov/pubmed/27563488 http://spie.org/Publications/Proceedings/Paper/10.1117/12.2043872 Dataset Download Link: https://www.kaggle.com/paultimothymooney/breast-histopathology-images Let’s start working on the dataset. Step 1: Import Libraries Step 2: Explore Data The module finds all the pathnames matching a specified pattern according to the rules used by the Unix shell, although results are returned in arbitrary order. glob imagePatches = glob( , recursive= ) filename imagePatches[ : ]:
    print(filename) '/kaggle/input/IDC_regular_ps50_idx5/**/*.png' True for in 0 10 Now make a function that can plot an image. image_name = image = cv2.imread(image_name)
    image = cv2.resize(image, ( , ))
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)); plt.axis( ) plotImage(image_name) "/kaggle/input/IDC_regular_ps50_idx5/9135/1/9135_idx5_x1701_y1851_class1.png" #Image to be used as query : def plotImage (image_location) 50 50 'off' return I created a function plotImage that takes the image path and plot the image, here is the result of the function. Let’s plot sample images of the dataset. bunchOfImages = imagePatches
i_ = plt.rcParams[ ] = ( , )
plt.subplots_adjust(wspace= , hspace= ) l bunchOfImages[: ]:
    im = cv2.imread(l)
    im = cv2.resize(im, ( , )) 
    plt.subplot( , , i_+ ) plt.imshow(cv2.cvtColor(im, cv2.COLOR_BGR2RGB)); plt.axis( )
    i_ += # Plot Multiple Images 0 'figure.figsize' 10.0 10.0 0 0 for in 25 50 50 5 5 1 #.set_title(l) 'off' 1 r = random.sample(a, )
    plt.figure(figsize=( , ))
    plt.subplot( )
    plt.imshow(cv2.imread(r[ ]))
    plt.subplot( )
    plt.imshow(cv2.imread(r[ ]))
    plt.subplot( )
    plt.imshow(cv2.imread(r[ ])); 
randomImages(imagePatches) : def randomImages (a) 4 16 16 131 0 132 1 133 2 Step 3: Preprocess Data For training and testing, we need to pre-process our , because of the dataset is not in the desired format. data Right now we have a bunch of images and we don’t have any idea of which image is IDC(+) and IDC(-). So we can not set the value of Y in our training. To find which image IDC(+) and IDC(-) we need to process the name of the image, if the end of the image name has then the image belongs to IDC(-) and it has then it belongs to IDC(+). class0.png class1.png patternZero = patternOne = classZero = fnmatch.filter(imagePatches, patternZero)
classOne = fnmatch.filter(imagePatches, patternOne)
print( ,classZero[ : ], )
print( ,classOne[ : ]) '*class0.png' '*class1.png' "IDC(-)\n\n" 0 5 '\n' "IDC(+)\n\n" 0 5 Now let’s make a function called proc_images that process every image and return and . x y where is our image and labels if images are in then label will be otherwise x y class0 0 1. X,Y = proc_images( , )
df = pd.DataFrame()
df[ ]=X
df[ ]=Y
X2=df[ ]
Y2=df[ ]
X2=np.array(X2)
imgs0=[]
imgs1=[]
imgs0 = X2[Y2== ] # ( = no IDC, = IDC)
imgs1 = X2[Y2== ] 0 90000 "images" "labels" "images" "labels" 0 0 1 1 Description of the dataset: def describeData(a,b):
    print( .format(len(a)))
    print( .format(np.sum(b== )))
    print( .format(np.sum(b== )))
    print( .format( *np.mean(b)))
    print( .format(a[ ].shape))
describeData(X2,Y2) 'Total number of images: {}' 'Number of IDC(-) Images: {}' 0 'Number of IDC(+) Images: {}' 1 'Percentage of positive images: {:.2f}%' 100 'Image shape (Width, Height, Channels): {}' 0 Results of the function: Total number images: IDC(-) Images: IDC(+) Images: Percentage positive images: %
Image shape (Width, Height, Channels): ( , , ) of 90000 Number of 66025 Number of 23975 of 26.64 50 50 3 dict_characters = { : ‘IDC(-)’, : ‘IDC(+)’}
print(df.head( ))
print(“”)
print(dict_characters) 0 1 10 Plotting sample images as IDC(-) and IDC(+) def plotOne(a,b): plt.subplot( , , )
    plt.title( )
    plt.imshow(a[ ])
    plt.subplot( , , )
    plt.title( )
    plt.imshow(b[ ])
plotOne(imgs0, imgs1) "" "
    Plot one numpy array
    " "" 1 2 1 'IDC (-)' 0 1 2 2 'IDC (+)' 0 def plotTwo(a,b): row range( ):
        plt.figure(figsize=( , )) col range( ):
            plt.subplot( , ,col+ )
            plt.title( )
            plt.imshow(a[ +row+col])
            plt.axis( )       
            plt.subplot( , ,col+ )
            plt.title( )
            plt.imshow(b[ +row+col])
            plt.axis( )
plotTwo(imgs0, imgs1) "" "
    Plot a bunch of numpy arrays sorted by label
    " "" for in 3 20 10 for in 3 1 8 1 'IDC (-)' 0 'off' 1 8 4 'IDC (+)' 0 'off' Plotting histogram of the dataset: def plotHistogram(a): plt.figure(figsize=( , ))
    plt.subplot( , , )
    plt.imshow(a)
    plt.axis( )
    plt.title( Y[ ] )
    histo = plt.subplot( , , )
    histo.set_ylabel( )
    histo.set_xlabel( )
    n_bins = plt.hist(a[:,:, ].flatten(), bins= n_bins, lw = , color= , alpha= );
    plt.hist(a[:,:, ].flatten(), bins= n_bins, lw = , color= , alpha= );
    plt.hist(a[:,:, ].flatten(), bins= n_bins, lw = , color= , alpha= );
plotHistogram(X2[ ]) "" "
    Plot histogram of RGB Pixel Intensities
    " "" 10 5 1 2 1 'off' 'IDC(+)' if 1 else 'IDC(-)' 1 2 2 'Count' 'Pixel Intensity' 30 0 0 'r' 0.5 1 0 'g' 0.5 2 0 'b' 0.5 100 Dataset split in Training and Testing: The is scaled from 0 to 256 but we want it to be scaled from 0 to 1. This will make the data compatible with a wide variety of different classification algorithms. We also want to set aside 20% of the data for testing. This will make the trained model less prone to overfitting. And finally, we will use an oversampling strategy to deal with the imbalanced class sizes. data X=np.array(X
X=X/ X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size= print( , X_train.shape)
print( , X_test.shape) 255.0 0.20 "Training Data Shape:" "Testing Data Shape:" Training Data Shape: (72000, 50, 50, 3) Testing Data Shape: (18000, 50, 50, 3) Converting Y in categorical Y_trainHot = to_categorical(Y_train, num_classes = )
Y_testHot = to_categorical(Y_test, num_classes = ) 2 2 Plotting Labels lab = df[ ]
dist = lab.value_counts()
sns.countplot(lab)
print(dict_characters)
{ : , : } 'labels' 0 'IDC(-)' 1 'IDC(+)' We have a class imbalanced dataset, let’s deal with it. Dealing with class imbalanced { : , : } 0 'IDC(-)' 1 'IDC(+)' Step 4: Define Helper Functions for the Classification Task sklearn.utils class_weight
class_weight = class_weight.compute_class_weight( , np.unique(Y_train), Y_train)
print( ,class_weight) sklearn.utils class_weight
class_weight2 = class_weight.compute_class_weight( , np.unique(Y_trainRos), Y_trainRos)
print( ,class_weight2)
Old Class Weights:  [ ]
New Class Weights:  [ ] from import 'balanced' "Old Class Weights: " from import 'balanced' "New Class Weights: " 0.68126337 1.87920864 1. 1. Step 5: Traning of Model For training our model Batch size = 128 Epochs = 15 After 8 Epochs val_acc did not improve so model training stopped. Step: 6 Evaluate Classification Model score = model.evaluate(X_testRosReshaped,Y_testRosHot, verbose= )
print( , score[ ], )
y_pred = model.predict(X_testRosReshaped)
map_characters = { : , : }
print( , sklearn.metrics.classification_report(np.where(Y_testRosHot > )[ ], np.argmax(y_pred, axis= ), 
target_names=list(map_characters.values())), sep= )    
Y_pred_classes = np.argmax(y_pred,axis= ) 
Y_true = np.argmax(Y_testRosHot,axis= ) 1 '\nKeras CNN #1C - accuracy:' 1 '\n' 0 'IDC(-)' 1 'IDC(+)' '\n' 0 1 1 '' 1 1 plot_learning_curve(history)
plt.show() confusion_mtx = confusion_matrix(Y_true, Y_pred_classes) 
plot_confusion_matrix(confusion_mtx, classes = list(dict_characters.values())) 
plt.show() It does not look too be to overfit or too biased based on the learning curve and confusion matrix. In the future, I will improve the score by optimizing the data augmentation step as well as the network architecture. Related Articles: Sentiment analysis of Amazon product reviews License Plate Detection (ANPR) Part2 All You Need To Know About ANPR Part1 If you found this article useful please clap and follow me, it will encourage me to write articles on tech. That’s all about this article I hope you liked it. Also published behind a paywall on Medium's subdomain .

Breast Cancer Detection Using Histopathology Images

Stories, News & Mentions about BGR

Bgr’s Stories on HackerNoon

Bgr's News & Mentions