DEV Community: MusabShakil

What is agent in AI

MusabShakil — Sat, 01 Jul 2023 22:33:12 +0000

An AI agent, also known as an artificial intelligence agent, is a software program or system designed to perform specific tasks or make decisions autonomously, often using machine learning and other AI techniques.

What does an AI agent do?

The primary goal of an AI agent is to interact with its environment, gather information, analyze it, and take actions to achieve its objectives. An AI agent can performs tasks such as data analysis, decision-making, natural language processing, image recognition, playing games, and personalized recommendations.

What are the 4 agents in AI?

There are several AI agents available that cater to different needs and objectives. Let's take a look at four notable AI agents:

Auto-GPT, is an AI agent that offers autonomous operation and the ability to access the internet for information gathering. It utilizes GPT-4, a state-of-the-art text generation model. Auto-GPT is also extensible through the use of plugins and provides file storage capabilities. However, it's worth noting that Auto-GPT is an experimental application with potential cost concerns and may not align with real-world practices, with limited liability for any consequences.
BabyAGI, is a Python script-based AI agent that leverages OpenAI and vector databases like Chroma or Weaviate. It enables the creation, prioritization, and execution of tasks based on previous task results and a predefined objective. BabyAGI's pros include its task management capabilities and integration with powerful databases. However, running the script continuously can lead to high API usage, and it requires proper setup of the OpenAI API before use.
MiniAGI, is a minimal general-purpose autonomous agent designed for various tasks such as analyzing stock prices, conducting network security tests, creating art, and even ordering pizza. It combines a robust prompt with a minimal set of tools, chain-of-thoughts, short-term memory, and self-criticism. While MiniAGI offers flexibility and utility, caution should be exercised as the agent may inadvertently suggest harmful commands or code. Additionally, depending on settings and requirements, MiniAGI might share data with third-party API providers like OpenAI, which can raise privacy concerns.
SuperAGI, is a dev-first open source autonomous AI agent framework that empowers developers to build, manage, and run useful autonomous agents. It provides features such as provisioning, spawning, and deploying agents, extending agent capabilities with tools, concurrent agent execution, and a graphical user interface. While SuperAGI offers a range of functionalities, being an actively developed project means that it may still have issues and bugs. Users should exercise patience, understanding, and report any encountered problems.

Which is the most powerful AI agent?

Among the mentioned AI agents, Auto-GPT stands out as the most powerful one. With over 140,000 stars on GitHub, Auto-GPT offers a comprehensive set of features. These include internet access for searches and information gathering, long-term and short-term memory management, GPT-4 instances for text generation, access to popular websites and platforms, file storage, and summarization with GPT-3.5. Additionally, Auto-GPT provides extensibility through plugins, allowing users to customize and enhance its functionality.

What are the three types of agents in AI?

There are three fundamental types of agents commonly found in AI:

Simple Reflex Agents: These agents make decisions based solely on the current percept, disregarding the percept history. They follow a condition-action rule, which maps a condition to an action. Simple reflex agents operate effectively in fully observable environments. However, in partially observable environments, they may encounter infinite loops unless they can randomize their actions. These agents have limited intelligence and lack knowledge of non-perceptual parts of the state.
Goal-Based Agents: Goal-based agents decide their actions based on the distance between their current state and a predefined goal state. Each action they take aims to reduce this distance and bring them closer to the goal. These agents rely on explicit knowledge that supports their decision-making and allows for modifications. Goal-based agents often require search and planning algorithms to determine the best course of action.
Learning Agents: Learning agents have the ability to learn from past experiences and improve their performance over time. They start with basic knowledge and adapt automatically through learning. Learning agents consist of four conceptual components: a learning element, a critic that provides feedback on performance, a performance element responsible for selecting actions, and a problem generator that suggests actions to generate new informative experiences. Learning agents can acquire knowledge and improve their decision-making capabilities through interactions with the environment.

Consequences of using AI agents

When using AI agents, especially in scenarios where they have the ability to write/execute scripts and run shell commands, it is important to consider potential consequences and take necessary precautions. To mitigate risks and prevent harm to the main computer's system and data, it is recommended to use a virtual machine/container (docker) for tasks that require high security measures. Running AI agents within a virtualized/containerized environment provides an added layer of protection. This becomes even more crucial if the AI agents are granted the ability to interact with sensitive systems or data. Taking these precautions helps ensure a safer and more controlled environment for AI agent usage.

Don’t Target Your Target Audience

MusabShakil — Mon, 12 Jun 2023 17:42:40 +0000

After launching the Minimum Viable Product (MVP) of Quickfix AI, my main focus shifted to attracting customers.

Who were my Target Audiences? 🤔

In today’s age, with the majority of work revolving around extracting relevant information from vast amounts of data, developers need to search the internet for bug-fixing information, and writers have to sift through numerous web pages to find inspiration, citations, and more. Additionally, Gen-Zs are now more inclined towards consuming short-form content, be it in the form of videos or text.

With this knowledge, I initially defined "developers" and "writers" as the target audience for my product. The strategy was to build a niche product that would first serve a small audience in a specific vertical and then expand to other verticals and industries. This approach would allow me to instantly validate my product and create a feedback loop to ensure that it meets the needs and expectations of users. It's a similar strategy to what companies like Facebook used in their early days when they launched their product exclusively within Harvard University before expanding to other universities and eventually worldwide.

Still, developers and writers were broad target audiences. I further divided them into early adopters and the early majority. To validate the product, I needed to build four key components: Machine Learning, backend, hosting, and frontend.

However, I realized that I could validate the product without designing and developing the front end or deploying it onto a hosting service. This approach would allow me to go to market more quickly. To achieve this, I made the product open source, enabling developers to try it out as early adopters. Additionally, I added a Google Form waitlist in the GitHub repository for writers who aren't tech-savvy and struggle with setting up a GitHub repository.

By doing so, when developers provide positive feedback on the product, I can complete the remaining key components and begin onboarding writers.

Growth 🚀

In my previous product development experiences, I utilized Product Led Growth (PLG) and Twitter, among others. This time, I wanted to explore new channels to reach my audience. Considering the high search volume for relevant keywords related to Artificial Intelligence, I planned to publish valuable content to maximize organic user acquisition. This included writing relevant blog posts, creating use case videos on YouTube, and sharing the product on relevant subreddits. Additionally, I aimed to generate growth by engaging with potential users on an individual level through personalized cold outreach and addressing their specific pain points based on their immediate feedback.

Out of all the channels, two performed exceptionally well: blog posts and subreddits. In 2 months, the GitHub repository had crossed 50 stars.

25 unique visitors in the last month, from 05th May 2023 to 05th June 2023.

3 unique visitors from Reddit and 10 unique visitors from DEV Community blog posts in the last month.

And 33 waitlisted users in Google Form since 8th February 2023 (last 4 months) when Quickfix AI was launched on GitHub.

Problem with Writers 🫠

As developers automatically started using Quickfix AI through organic channels, it was the perfect time to onboard writers through cold email and showcase developers' testimonials as social proof, making it easier for writers to take their first step.

However, I soon realized that writers weren't interested in using Quickfix AI. I sent over 70 personalized emails, following email strategies from Art of Emails, Marketing Examples, and Lead Feeder, which included PAS (Problem, Agitate, Explain) and AIDA (Attention, Interest, Desire, Action) frameworks, and offering genuine upfront value. Despite an 80% open rate, I received no responses.

Why are writers behaving like this? 🧐

After exploring writer communities on subreddits and other platforms, it became apparent that most writers aren't happy with the new AI revolution. It is taking over their jobs and gigs, from Hollywood to WordPress blogs. Clients are opting for algorithmic efficiency and replacing human talent. Writers now have a certain skepticism about using AI products. Current AI startups that allow users to generate articles, emails, and documents are mainly used by non-professional writers (you and me) looking to enhance their content.

Now, it's time for me to go back to finding an Ideal Customer Profile (ICP), for whom Quickfix AI solves their real pain.

Get Instant Error Solutions with GPT

MusabShakil — Tue, 21 Feb 2023 21:13:34 +0000

Recently I found myself using ChatGPT a lot, I was at a point where I even left Google and Stackoverflow (my two best coding friends). But ChatGPT has two problems:

If I don't provide my source code as context to ChatGPT, it behaves like a large language model and provides some random answers from its brain, which mostly aren't useful and meaningful. So I've to make it pretend like "ChatGPT, you are now a software engineer" by writing some prompts curated by awesome people at awesome-chatgpt-prompts.
Even if I provide my source code to ChatGPT, then write my query or code error which I want ChatGPT to solve, most of the time my source code is too big it just exceeds the ChatGPT input limit.

Solution 💡

After thinking about this problem I came up with a plan to build a VS Code extension which can directly extract source code from IDE, so I don't have to copy paste the code every time I've to ask ChatGPT for the answer of errors in my code, and I use vector database as an index to store embeddings for my source code, which basically do an approximately nearest neighbors similarity search to just pick those snippets from my code which are the causing the error, in this way I'm able to input only a small chunk of source code into the GPT model which performs well and provide accurate solution for the errors without exceeding the OpenAI GPT input limit.

I made the VS Code extension publicly available for free on GitHub. It's currently in Alpha stage, and I would appreciate your Pull Requests/Contributions to this open source tool. Before diving into the extension, let's understand why we need it.

What are the existing solutions? 🤔

Today's Gen AI dev tools, such as Copilot, are missing the mark. Yes, they help with code completion, but every developer knows that programming is really 20% coding and 80% debugging. I asked myself, how can LLMs help with the crucial, time-sensitive, frustrating, and just incredibly intense task of debugging?

Introducing 👋

Quickfix AI, an extension for VS Code that provides you instant solutions for errors in your code within the code editor using AI.

With quickfix.ai, you can:

🧠 Get instant solution for error in real-time
💡 Increase your coding understanding and efficiency
⏳ Save time and minimize frustration with clear code solutions
🔍 Improve your coding skills with in-depth code analysis

Demo 📽

Installation 📦

Quickfix AI is in its Alpha phase, if you would like to use and explore it at this stage, you can follow the steps below to set it up. However, if you prefer to wait for a more reliable version with an easy installation process through VS Code Marketplace, you can Join the Waitlist for the Stable release.

Prerequisite:

Python v3.10 + Poetry
Node v16 + Yarn

Setup:

Clone Quickfix AI repo
Build the vscode-extension make install-vscode-extension
Build the backend make install-backend
Update the environment variables in both folders, /vscode-extension/src/env.ts (you probably don't need to update this file if your backend will be running in the localhost or 127.0.0.1) and /backend/.env
Run the backend make run-backend

How to Use Quickfix AI 🛠

Open a workspace/folder in VS Code
Open the Command Palette (press Ctrl + Shift + P or Cmd + Shift + P on Mac)
Type "Quickfix AI" and select the command from the list
Paste/enter your error or question.
Wait for the response and the solution will be displayed in a "solution-by-quickfix-ai markdown" file in your VS Code editor

Enjoy the instant and comprehensive error solutions with Quickfix AI! 🎉

Save Gas Fees on NFT using ERC721A Standard

MusabShakil — Thu, 22 Dec 2022 13:54:07 +0000

In the past two years if you are into the crypto space then you've probably experienced the boom of NFT (Non-Fungible Token). The biggest problem it brings along with itself is the high gas price and network congestion in the Ethereum blockchain. The easiest solution is to use a Layer-2 or EVM compatible blockchain which supports smart contract, but as more big players in the industry like Yuga Labs (Creators of Bored Ape Yacht Club and Otherside) and Moonbirds are opting for Ethereum blockchain the gas problem has become worse day by day.

Smart Contract Developers at Sandbox, Cool Cats, and almost every other NFT startup have faced the same issue, many trying to optimize their smart contracts in their own way. Developers at Chiru Labs (Creators of Azuki) came up with the new ERC (Ethereum Request for Comment) standard for NFT called ERC721A to supersede the previous standard ERC721 which was proposed by the EIP (Ethereum Improvement Proposals).

Let's understand the problem 🥀

If you aren’t familiar with the term "gas fee", it's a payment made by users to execute transactions on the Ethereum blockchain. The fee is paid in "ether", the cryptocurrency used on Ethereum, and is calculated based on demand for block space on the network. The amount of the fee is expressed in "gwei", which is 10^(-9) ETH. Gas fees are typically set automatically by a user's wallet.

During times of high demand for NFTs, such as when a popular NFT project releases new items, it can lead to a surge in the number of transactions being executed on the Ethereum blockchain. This can result in a phenomenon known as a "gas war", where the price of gas spikes significantly. This can have a negative impact on the user experience, as the high gas fees can make it more expensive to execute transactions on the network.

For example, the popularity of the Loot project led to a rush of users trying to mint and list Loot derivatives, which caused several spikes in gas fees and raised the price of transactions across the Ethereum network. The plots illustrate how the gas fees rose significantly whenever Loot derivatives were minted.

Understanding the scale of the problem 📈

The Ethereum blockchain has relatively high gas fees compared to other blockchain networks, with the cost of executing a transaction ranging from a few dollars to over $500, depending on the complexity of the transaction and the level of demand on the network. This means if an NFT costs you $200, with the inflated gas prices you have to pay $700 ($200 + $500).

What is ERC721A 🌹

ERC721A is a version of the IERC721 (I in IERC721 means Interface) standard that allows for more efficient creation of multiple NFTs in a single transaction, resulting in cost savings in terms of gas fees, potentially as much as 80% compared to other methods. The timeline of ERCs are:

ERC721 -> ERC721 OZ -> ERC721A

Additionally, this solution can help mitigate the network congestion that is commonly experienced on the Ethereum blockchain when creating NFTs, as it minimizes the amount of data required to be stored in the token metadata and updates the ownership state only once per batch of minting.

A technical deep dive 🔬

ERC721A has introduced three optimizations in the previously used smart contract implementation developed by OpenZeppelin (OZ).

1. Removing duplicate storage from OZ ERC721Enumerable
The OZ implementation of the IERC721Enumerable standard, which is widely used, includes redundant storage of metadata for each individual token. This approach is optimized for read functions but can be costly in terms of gas fees for write functions, which are less commonly used and often require a higher fee to be executed. Additionally, the fact that the tokens are numbered sequentially in the new implementation from 0 allows for the removal of some redundant storage from the base implementation.

2. Updating the owner’s balance once per batch mint request, instead of per minted NFT
Suppose Alice currently owns 2 tokens and wants to purchase an additional 5 tokens. In the Solidity programming language, it costs gas to update stored values. Therefore, it would be more cost-effective to update Alice's token holdings from 2 to 7 in a single update, rather than performing 5 separate updates (from 2 to 3, 3 to 4, etc.) to track the addition of each individual token. This is because updating a stored value multiple times incurs additional gas costs, whereas updating the value in a single transaction only incurs the cost once.

3. Updating the owner data once per batch mint request, instead of per minted NFT
This optimization is similar to the previous one in that it aims to reduce the number of updates made to stored values in order to save on gas costs. In this example, Alice wants to purchase 3 tokens numbered 100, 101, and 102. Instead of updating the ownership information for each individual token (which would incur 3 separate gas costs), it would be more efficient to update the ownership information just once in a way that semantically indicates that Alice owns all 3 of these tokens. This would result in a single update rather than 3, reducing the total gas cost.

Suppose Alice and Bob are minting NFTs. Specifically, Alice is minting tokens numbered 100, 101, and 102, and Bob is minting tokens numbered 103 and 104. The internal owner tracker is a system for keeping track of the ownership of these NFTs, and in this case, it would look like this:

The key point being made in this statement is that it is possible to determine the owner of an NFT without having to explicitly store the ownership information for that specific NFT. This can be done by modifying the "ownerOf" function to use a different method for determining the owner of the 102 NFT.

function ownerOf(uint256 tokenId) public view virtual override returns (address) {
  require(_exists(tokenId), "ERC721A: owner query for nonexistent token");

  uint256 lowestTokenToCheck;

  if(tokenId => maxBatchSize) {
    lowestTokenToCheck = tokenId - maxBatchSize + 1;
  }

  for(uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
    address owner = _owners[curr];
    if(owner != address(0)) {
        return owner;
    }
  }

  revert("ERC721A: unable to determine the owner of token");
}

An important thing to understand is that the function ownerOf will continue to operate correctly if we modify it to decrease the value until it locates a specifically designated owner.

Now let's see with an example on how we can mint an NFT using ERC721A.

First of all, initialize a Node project.

npm init -y

Install Hardhat (Ethereum Development Environment).

yarn add hardhat -D

Setup a Solidity project.

npx hardhat

> Create a TypeScript project
> Hardhat project root: if not provided then enter your current working directory
> Do you want to add a .gitignore? y
> Help us improve Hardhat with anonymous crash reports & basic usage data? y
> Do you want to install this sample projects dependencies with yarn (...)? y

This will initialize various elements in our project, including Hardhat's default settings with TypeScript support.

We now have a functional development environment, which includes a simple example contract called Lock.sol or Greeter.sol. However, this contract will not be useful for our purposes. Let's create a new file in the contracts folder called BoredLion.sol.

To utilize ERC721A, we simply need to install it. This package depends on another package provided by OZ, so it's a good idea to include it as well.

yarn add erc721a @openzeppelin/contracts -D

Finally, we can write the Solidity code inside the BoredLion.sol file, which allows us to mint our very own NFT called BoredLion.

//SPDX-License-Identifier: MIT  
pragma solidity ^0.8.11;  

import "erc721a/contracts/ERC721A.sol";  

contract BoredLion is ERC721A {  
  constructor() ERC721A("Our Bored Lion", "BoredLion") {}  

  function mint(uint256 quantity) external payable {
    _safeMint(msg.sender, quantity);  
  }  
}

Closing thoughts 🌺

ERC721A has a wide range of potential use cases and can offer significant cost savings in terms of gas fees. The purpose of this article was to introduce ERC721A and highlight its potential benefits for developers looking to create NFT on the Ethereum blockchain. Check out all the features in the documentation. In case you have some questions regarding the article just leave a comment or want to discuss something feel free to connect with me on LinkedIn.

Special thanks to TokenMinds, CoinsBench and nft now

If you work at a web3 startup and want me to write for your product please do connect with me 🍀

A Guide to Branching and Online Schema Changes with PlanetScale 2023

MusabShakil — Wed, 21 Dec 2022 10:50:25 +0000

As a dev, you've most likely encountered the database migration issue, when you've a working production environment and you try to run the migration command from development or staging to production and it cause a conflict in your production database because you've altered the table in your development and now its not able to sync those changes properly.

Database Administrators and Engineers at big tech companies and almost every other business have experienced this issue, many tried to build their own solutions and few of them published their solutions as an open source project, and the terms used for this solution are branching and online schema changes.

Let's examine the problem to see what's going on 🧤

Merging the individual work of a big team of engineers into one database is difficult. Conflicts can become more difficult to resolve when simultaneous changes are made to multiple sections of code that are dependent on each other.

For example, if one developer changes the schema of a table by adding a new column, and another developer attempts to insert data into the table using the old schema, a migration conflict will occur. In this case a queue needs to be implemented in the migration workflow and the common scenario is to use a branch to separate production databases from development.

Online schema changes are a technique that allows database administrators to alter the structure of a database without taking it offline. These changes can include adding or modifying columns in a table, altering the data type of a column, or renaming a table.

The main problem that online schema changes are trying to solve is the downtime that is typically required when making structural changes to a database. In traditional database management systems, making changes to the schema of a database often requires taking the database offline, which can cause disruption to applications and services that rely on the database. Online schema changes allow database administrators to make these changes without taking the database offline, which minimizes downtime and makes it easier to maintain and evolve the database over time.

How severe is the problem? 🤔

Tesla performs upto 130 deployments per day. Around a million electric vehicles are currently roaming around on the roads. A single conflict while merging databases to production can cause a hefty loss to the company. Similar could happen to other companies including Instagram which deploys 30-50 times a day.

Process of Branching 🛣

Branching can be accomplished in just a few steps.

Create a separate branch from your production branch to use for development purposes. This branch will be a copy of your production schema that you can modify without affecting the production environment.
Modify the structure of this copy of your database by making changes such as removing a column or adding a new table.
Test the changes you made to the database structure in a development environment to ensure that they are functioning correctly.
Create a comparison between the production and development schemas. This will allow you to review and understand the changes that will be implemented, and the issues with the schema, such as missing unique keys, that need to be addressed before the deployment happens.
Now to deploy development to production in zero downtime, you need to carry out the process of online schema changes.

Process of Online Schema Changes 🐣

Online Schema Changes follows a pretty simple pattern.

Make a new table that is identical to the development table, but without any data. We'll call this the "ghost" table.
Modify the ghost table through an ALTER statement without any additional cost, as it is empty.
Initiate a lengthy process of transferring rows from the production table to the ghost table, doing so in small increments.
Once the copying of the existing data is finished, the migration is typically ready to switch over to the new system.
The final step in the process is the cut-over, which involves renaming the production table and replacing it with the ghost table. This may cause a brief outage, but in general, users and applications will not be aware that the table has been swapped out from under them.

Which products are tackling this issue? ⛑

Several products are trying to solve this problem and in doing so they are making the process as simple as possible so you don't have to implement branching and online schema changes on your own.

Cockroach Labs provides a free forever plan but has some limitations related to online schema changes.

YugabyteDB has a free tier only for educational and non-production use. It has multiple unsafe DDL operations in both of its query languages, YSQL and YCQL.

PlanetScale also has a free-forever tier, and it just have two limitations, FOREIGN KEY constraints and RENAME for columns and tables, which can be easily solved through their easy to follow tutorials, FOREIGN KEY solved and RENAME solved, so with these solutions they completely eliminated all of their drawbacks.

Conclusion ✨

PlanetScale not only addresses issues with branching and online schema changes, but also offers a range of unique features that are not available in other products and services. Check out all the features in the documentation. Don't wait too long, create your account and get started with PlanetScale. In case you have some questions regarding the article or want to discuss something feel free to connect with me on LinkedIn 💖

If you work at a startup and want me to write for your product please do connect with me 🥰

Simplify Image Labelling For ML Using Roboflow

MusabShakil — Sat, 17 Dec 2022 20:16:41 +0000

While building a machine learning project you probably came across a point in time where you need to decide which tool should I use to annotate my raw images for training and testing purposes. You may ask, why not just go with any one of the available data labelling tools?

Let's understand the problem 🧐

Labelling and annotating images can be a time-consuming process, especially for large datasets. Humans can make mistakes while labelling and annotating images, which can lead to errors in the final dataset. Different image labelling and annotation tools may use different standards and conventions, which can make it difficult to compare and integrate datasets from different sources. Many image labelling and annotation tools are not designed to handle large datasets, which can limit their usefulness for certain applications. Some image labelling and annotation tools can be expensive to use, which can be a barrier for smaller organizations or individuals. Some may not be robust enough to handle complex or noisy images, which can lead to incorrect or incomplete annotations. And some may have a steep learning curve or may be difficult for users to understand and use effectively.

How big is this problem? 🤔

If we take the example of the world's biggest autonomous vehicle manufacturer, Tesla. Their head of AI and computer vision, Andrej Karpathy, revealed that Tesla only has a "few dozen engineers" working on neural networks, but they have a "huge" team working on labelling.

According to Pinterest, they use Amazon Mechanical Turk, which is a distributed workforce who can perform image labelling and similar tasks virtually. At Pinterest, they have a growing dataset of billions of ideas, and they are tasked with showing the right idea to the right user at the right time. Taking advantage of Amazon Mechanical Turk’s powerful crowdsourcing platform, they built a high-quality human evaluation system that could scale with their needs.

Overall big organizations are handling more than a million of images each year and spending a lot of their developer hours into the object annotation process. So this task is a big part of their Machine Learning workflow.

What is Image Labelling? 🏞

Image labelling is exactly what it sounds like — it's the process of assigning labels or tags to images based on their content. The labels can be used to categorize and organize images, as well as to describe their content in a machine-readable format.

For example, image labelling might involve assigning labels such as "cat," "dog," "car," or "flower" to images of those objects. Image labelling can be done manually by humans, or it can be automated using machine learning algorithms.

Image labelling is an important step in many applications of computer vision, such as object recognition, image classification, and image search.

Processes involved in Image Labelling 🛠

Image labelling operates on a rather simple basis. Suppose we have 2 NFTs of different collections, one is Bored Ape Yacht Club and another one is Pancake Squad.

Our first step would be to select the images that need to be labelled. This may involve selecting a specific subset of images from a larger dataset, or it may involve selecting images from various sources if we are trying to take NFT derivatives in consideration.
The next step is to define the labels or tags that will be used to classify the images. This may involve defining a set of predefined labels, or it may involve creating a custom set of labels for a specific application. We'll use ape and pancake as our labels.
The third step is to label the images based on their content. This can be done manually by humans, or it can be automated using machine learning algorithms. We'll go the manual way.
Once the images have been labelled, it is important to verify that the labels are accurate and complete. This may involve manually reviewing the labels, or it may involve using ML algorithms to check for errors or omissions. Again we'll choose the manual path.
In some cases, it may be necessary to add additional metadata or context to the images. This process is known as image annotation, and it can involve adding additional labels, text, or other information to the images. We'll skip this one.
The final step in the image labelling process is to store and manage the labelled images in a way that allows them to be easily accessed and used for further analysis or processing. This may involve storing the images in a database or file system, or it may involve using a specialized image management tool. We'll use an image management tool and file system, but why? Let's discuss it.

Which products are solving this problem? 🤝

Heartex LabelImg created by Tzutalin is one of the popular choices of labellers but is no longer actively being developed. But, but it's now a part of the Label Studio community. Their cloud platform has just 14 days of free trial, you can use their cloud or open source product. But if you want to use it in your side projects and prefer browser softwares instead of local installation then 14 days might not be enough for you.

ImgLab is a free and a web based platform, but it lacks various computer vision annotation formats, which are essential if you need to train and experiment with distinct ML libraries and services.

Roboflow provides an image labelling feature that is easy to use and configure to our needs. It's free-forever for open-source projects and comes with a pay-as-you-go plan for private projects.

A technical deep dive 🚀

To understand the technical nuances in depth let's get our hands dirty and witness some of the features of Roboflow.

In a big organization labelling images is not the only problem we have. We must assign each image to the right person, make sure it is reviewed before moving on to the next stage, set labels, structure projects and the list can go on and on. You can use Roboflow to solve all these problems. The amount of features Roboflow provides, it is hard to fit in this one blog, so let's try out some of them. In this hands-on we'll be:

assigning images to a team member
annotating these images
exporting images to a specific format for a machine learning model

Let's now start by creating an account in Roboflow.

https://app.roboflow.com/login

Connect with a third-party provider or use your email and password to sign up.

The best part of Roboflow is that it provides an interactive user onboarding tour, you can follow that or continue along with me.

I've created a project and named it as NFT Detection, you can choose a name according to your project.

We landed on our project page. Roboflow has displayed numerous features on the left sidebar, we'll cover a few of them which are related to image labelling.

Once we have our Roboflow project up and running, we can upload images, I've added 3 ape and 3 pancake images, I'll just click on Save and Continue.

It shows a dialog to assign images to the teammates, as I'm the only person in this Roboflow project, I'll assign these images to myself.

On the Annotate page click on one of the Unannotated images, it'll open a canvas to annotate your image.

Choose the Bounding Box Tool from the right hand side panel (if it's not already selected), click and drag the mouse to create as perfect box as you can around your object, and name the label accordingly, I'll name mine one as ape.

Follow the same procedure as of the above two paragraphs for the other Unannotated images and label them according to the image, I'll label remaining 2 of Bored Ape Yacht Club as ape and other 3 as pancake.

Once we have all the images annotated, we'll click on the Add 6 images to Dataset button (the number 6 might be different according to your data).

Adjust Train-Valid-Test split or leave it as it is, and proceed to the Generate tab. You can edit preprocessing depending on your use case. I'll remove the Resize preprocessing.

Click on Generate > Export > Format YOLO v7 Pytorch (choose according to your needs) > download zip to computer > Continue.

Conclusion 🥁

There is no limit to Roboflow's features. This blog was created with the intention of piquing interest in this incredible tool that can help you save a ton of time and effort. Check the docs to see all the features. Create an account as soon as possible to begin using Roboflow. In case you have some questions regarding the article or would like to talk about anything feel free to connect with me on LinkedIn ✌️

Special thanks to Neurala, @aniket762 and owaiskhan

If you run an organization, and want me to write for you or you are hiring for a software engineer position please do connect with me 🦄

Track Your Job Search In Notion

MusabShakil — Sat, 26 Nov 2022 17:48:12 +0000

Recently I'm looking for a new job opportunity and I'm also using Notion a lot for various stuffs, so I thought why not just combine both of these things.

Previously when I applied to open positions I didn't keep track of them, so I didn't know how many times I applied, whether or not I'm applying to the same company twice, and are the companies ghosting me.

I looked around and found various Notion Job Tracker Templates, but I just need a simple one, so I made my own template, Minimalist Notion Job Tracking Template.

At this time I started applying to jobs, every time I submit an application I fill out my template with the details I need when I look back to this application for an interview or for following up with the recruiter.

Now the problem I'm facing is every time when I apply to a job I need to fill in the notion template, and I'm seeing a repetition here. As a software engineer I know the debt of doing things manually, so I started thinking how I can automate it.

I saw Notion recently publicize their APIs and allow integration/bot, so I read through their docs.

First of all, I need to make a new integration.

Then I created a Node.js project, installed the SDK @notionhq/client through npm package manager, and saved NOTION_DATABASE_ID and NOTION_KEY in a .env file.

With just a single method notion.pages.create which takes an object with a few properties as arguments I was able to enter job details successfully.

I ran this script in Replit which makes it really simple to iterate over new ideas and prototypes.

import { Client } from "@notionhq/client"

const notion = new Client({ auth: process.env.NOTION_KEY })

const databaseId = process.env.NOTION_DATABASE_ID

async function addItem(
  company, website, status, role, application
) {
  try {
    const response = await notion.pages.create({
      parent: { database_id: databaseId },
      properties: {
        Company: {
          title: [
            {
              "text": {
                "content": company
              }
            }
          ]
        },
        Website: {
          rich_text: [
            {
              text: {
                content: website,
                link: {
                  url: website
                }
              }
            }
          ]
        },
        Status: {
          multi_select: [{
            name: status
          }]
        },
        Role: {
          rich_text: [
            {
              text: {
                content: role
              }
            }
          ]
        },
        Application: {
          rich_text: [
            {
              text: {
                content: application,
                link: {
                  url: application
                }
              }
            }
          ]
        }
      },
    })
    console.log(response)
    console.log("Success! Entry added.")
  } catch (error) {
    console.error(error.body)
  }
}

addItem(
  "Walmart",
  "https://www.walmart.com/",
  "sent",
  "Software Engineer",
  "https://careers.walmart.com/us/jobs/WD944268-software-engineer"
)

You might be thinking this code doesn't solve my problem of repetition, because in the addItem function I'm entering data manually. For that I've created a Chrome Extension which extracts all these fields from a job when I hit the submit button, so this blog post is just a small part of a bigger picture, but it doesn't mean you can't start right away. You can use my notion template and above code to get off the ground and explore new ways to automate job applications on your own until I share my Chrome Extension.

Btw I don't automate the portion where I've to fill up the job application, the portion where a company asks to upload a resume, cover letter and answer various other questions. I think I've better chance of getting hired by writing a personalized cover letter and answering all the other questions according to the company culture and their mission. I prefer quality over quantity. There is a subreddit which provides really good feedback on resumes. I learned various key things from the resume experts available there.

crypto is a scam

MusabShakil — Wed, 02 Feb 2022 11:05:18 +0000

are you skeptical about crypto, not sure about blockchain, thinking of it like an mlm scheme, price looks volatile to you, when you invest market goes down?

there are lots of questions like these, maybe you have or maybe not, nevertheless will it not be awesome that you'll once again do your own research from scratch but with a step by step guide to clear up all your questions which will make you confident about the upcoming revolution of web3.

web3 for you is an ongoing list of curated stuffs related to blockchain, crypto and its underlying technology, this list is powered by open source community which can make additions into this list and will try to teach you about future in a less complex language.

blockchain and github users feel free to open pull requests to remove typos and include new technologies into this list.

Google and Facebook are combining forces (Here is the hint)

MusabShakil — Mon, 10 Jan 2022 10:05:38 +0000

In Jan 7, 2022 Stephen Hawking's 80th Birthday Doodle, YouTube show something incredible at 1:22 (01 min and 22 sec) of the video:

Hint is ReactJS Logo which is created by Facebook.

This is just my take on this Doodle video, maybe Google and Facebook aren't going to work together or this logo might be of something else not of ReactJS, what do you think, let me know about your thoughts in the comment section.

Error saving your changes: Description control characters are not allowed

MusabShakil — Thu, 06 Jan 2022 18:58:18 +0000

Did you ever come across this error while adding a lovely description after doing days of hard work on your project.

SOLUTION

Just remove the new line and it'll save properly.

1 package to solve all your frontend web3 problems

MusabShakil — Thu, 30 Dec 2021 20:16:19 +0000

When you think about Web3.0 what first comes into your mind?

Bitcoin, metaverse, nft, insane amount of money and Elon Musk. These are the things a regular person can think of, but what about tech geeks and programmers. The obvious thing that come into their mind is the battle between thousands of lines of code, handling blockchain node, interacting with its data which is humongous and trying to connect user's wallet to his website.

Solving few problems at a time, web3-react-wallet is doing its best to let us win this weird battle by providing a single source of truth (SSOT) where all the frontend web3 problems went down to this blackhole and we get a purified library that provides multiple wallet support, switching user's wallet chain, typescript and more.

I know you already start installing the package from npm but don't forget to visit the source code on GitHub to learn more:
https://github.com/MusabShakeel576/web3-react-wallet