DEV Community: Olorundara Akojede (dvrvsimi)

Building on the Edge: A How-To Guide on Object Detection with Edge Impulse

Olorundara Akojede (dvrvsimi) — Fri, 08 Sep 2023 11:55:28 +0000

In the fast-evolving landscape of technology, edge devices have emerged as the unsung heroes, bringing innovation closer to humans than ever before. From smart homes that make living easier to self-driving cars, these gadgets have redefined convenience and connectivity in ways that we could have never conceived.

At the heart of this disruptive transformation lies one of the powerful fields - object detection – a dynamic field of machine learning that equips machines with the ability to understand and infer from their visual surroundings.

This article talks about how you can build your own object detection model - a simple face mask detection project on Edge Impulse.

Prerequisite Knowledge:
Readers should have basic knowledge of machine learning concepts. Some understanding of IOTs is an added advantage.

Requirements:
You would need:

an Edge Impulse account
a Computer
a Kaggle account (optional)
a Phone (optional)

Introduction to Edge Computing

As you may already know, edge computing brings machine learning capabilities directly to edge devices, enabling real-time processing and decision-making without relying on the cloud, this means that your data stays with you in most cases. Unlike the traditional machine learning cycle, building for edge devices requires more iterative processes before they can be optimally deployed. Certain trade-offs have to be made depending on the the model's intended use and it is usually a contest between the model's size/compute time versus the model's performance.

There are various optimization techniques that are adopted for edge deployment and for compressing learning algorithms in general, some of them include:

Quantization: reduces the precision of the models parameters from 32-bit floating point values to 8-bit (int8) values without compromising the accuracy.
Pruning: reduces the size of decision trees by removing sections of the tree that are non-critical and redundant.
Distillation: transfers knowledge from a large model (teacher) to a smaller one(student).
Decomposition: uses smaller matrices or vectors in place of larger matrices while still retaining as much information as the original matrix.

See this article that extensively explains the above concepts, you can also check out this presentation by Kenechi, it simplifies the above listed techniques and a couple of other relevant information.

What is Edge Impulse?

Edge Impulse is a leading dev platform for machine learning on edge devices. It allows you to carry out everything from data collection to deployment and everything in between.
Whether you are dev looking to build models for deployment on your development board or an enterprise looking to deploy accurate AI solutions faster on literally any edge device, Edge Impulse has got you covered!

You can get around the platform easily and build projects in simple steps - build your dataset, train your model, test your model, and deploy it!
If you have done some form of ML before, these steps should be familiar to you.

Getting Started with Edge Impulse

Head over to https://edgeimpulse.com and create a free Developer account. Choose the Enterprise account if you intend to use your account for business purposes, it offers perks for .

Next, click the + Create new project button from the dropdown on the top-right of the screen and name your project.

Acquiring Data

To build a model that can tell when it sees a face mask, you need to show it images of varieties of face masks. If you have a face mask and would like to create your own dataset from scratch or you would rather use a public dataset to train your model, Edge Impulse provides data acquisition channels for both options.

Scroll down on the Dashboard page and click on the channel you'd like to use. Depending on the application, it is advisable to collect data with both channels to improve your model accuracy.

When adding existing data, you can either upload the data (as single units or as folder) or add a storage bucket. You can find and download face mask datasets here.

To collect your own data, you have 3 options; your computer, your phone, and/or a development board. To use your phone, simply scan the QR code to load the data acquisition page on your mobile device, you can proceed to collect data with your phone's camera.

Note that you can only use your back camera.

See the list of Edge Impulse supported dev boards

Preparing Data

Once you start uploading or collecting data, you would see a pop up asking if you want to build an object detection project. Scroll down to Project info on your Dashboard and change the Labeling method to Bounding boxes (object detection).

After changing the Labeling method, you would notice a new section called Labeling queue with a number in parenthesis, that number represents the number of images collected or uploaded.

Just like every drag and release operation you've done with your mouse/trackpad, select the region that contains the face mask and click on Save labels to save that entry. Repeat this process for all your samples.

You may decide that you don't want to train your model with some samples, you can easily click on Delete sample to remove them as you go through your dataset.

Still on the Labeling queue page, you would notice a dropdown menu called Label suggestions. If you were detecting common objects like cars, animals, or even faces, you can switch to the YOLOv5, it saves you the stress of having to draw bounding boxes manually. Track objects between frames works best if you collected the series of data in the same instance, it just finds patterns and predicts where the bounding box should be in the next sample.

Creating an Impulse

On the left menu, click on Impulse design, this is where you create the pipeline from input to processing to output.

Click Add an input block and add Images, you can change the Resize mode however you see fit. For Add a processing block, add Image and finally, add the Object detection(Images) learning block authored by Edge Impulse, be sure to tick the Image box. Click Save Impulse to save your configuration.

Generating Features

For each block you add, a new option is created under Impulse design. Click Image to explore how you can generate features from the samples.

It is advisable to change your colour depth from RBG to Grayscale, it significantly improves your model accuracy if you decide to use FOMO which would be covered in later sections of this article.

Click on Save parameters to go to the Generate features section and click Generate features.

Once you see the Job completed status, hover back to the left menu and click on Object detection. It's finally time to train your model!

Training your model.

Tweak the hyperparameters to your preference and choose your model.

About model selection, you can see a mini info card on each model when you click on Choose a different model. MobileNetV2 should do just fine for this use case but if you read through their info cards, you'd deduce that FOMO is a better option.

Fear Of Missing Out?

Anyone who hears or reads it for the first time would naturally think the same but FOMO(Faster Objects, More Objects) is a novel solution developed at Edge Impulse for more optimal object detection applications on highly constrained devices.

Apart from its negligible size, it is also very fast and can work on a wide range of boards. Check the documentation on FOMO here to know more and see how people are using it in interesting ways.

To use FOMO, ensure that you set the learning rate to 0.001 before training your model.

When you have adjusted the hyperparams and selected the model of your choice, click on Start training and wait for training completion.

Evaluating your model

After training, you should see an interface like the one below, it is a summary of the model's performance with the train data. Let's evaluate the model against new data.

Notice how you can switch the model's version from int8 to float32.

On the left menu, click on Model testing to evaluate your model with your test data (remember that if you didn't specify train to test ratio, Edge Impulse automatically splits the data into 80:20). Click on Classify all and wait for the result.

If you used a diverse dataset, your number should be higher the one in the image above. Diverse in the sense that your model should learn from face mask images in different colour, lightings, backgrounds, and angles. You probably want to include people with different skin colour so you don't end up with a bias model.

Inferencing

Now, you would perform face mask detection in real time. Go back to your Dashboard, click on the button that says Launch in browser, it is just below the QR code. Ensure that your computer has a webcam or an external one attached, if it doesn't, you can scan the code with your phone camera and switch to Classification mode.

On the newly opened tab, a mini web app for inferencing would be created. When the build is complete, you would be asked to grant access to your webcam. Happy inferencing!

What next?

You have learned how to build a simple object detection model on Edge Impulse but it gets more interesting when you start integrating hardware.

A good application of this project would be to create an automatic door system that won't open for a person that isn't putting on a face mask. On an Arduino board, the .ino *code would be something like this:

softmax_threshold = 0.6 // depending on your model performance
if (softmax_prediction > softmax_threshold) {
    Serial.println("Welcome");
    digitalWrite(door_gear, HIGH);
  }
  else {
    Serial.println("No entry without face mask")
    digitalWrite(door_gear, LOW);

*this is nowhere near complete or accurate and is just meant to give you an idea. An ideal code would take into account the #include for the required drivers and #define for the individual hardware pin configurations but that is outside the scope of this article.

Continue exploring Edge Impulse's capabilities by building more advanced models and trying your hands on hardware, the documentation is all there for you.

You can also explore other machine learning applications for edge computing.

Until next time, Tschüss!

The Magic of Attention: How Transformers Improved Generative AI

Olorundara Akojede (dvrvsimi) — Wed, 19 Jul 2023 07:20:41 +0000

Table of Contents.

Preamble
Encoder-Decoder Architecture
- The Encoder Network
- The Decoder Network
- Training on Encoder-Decoder Architecture
Limitations of the Traditional Encoder-Decoder.
"Attention is all you need"
- Overview of Attention Mechanism
Conclusion

Preamble.

Generative AI is the new buzzword in the world of AI, big enterprises are looking to incorporate generative features into their solutions and AI engineers are working now more than ever to train models that are taking strides that were once inconceivable to the human mind when it comes to generating content.

Watch this video of Sundar Pichai (Chief Executive Officer at Google), it compiles all the times he said "AI" and "generative AI" during his keynote speech at Google IO, 2023: // Detect dark theme var iframe = document.getElementById('tweet-1669177584175677443-177'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1669177584175677443&theme=dark" }

Generative AI refers to a branch of artificial intelligence that focuses on generating new content based on patterns and examples from existing data, these contents may be in the form of a captivating story in text, an image of a landscape scenery from the Paleolithic era, or even an audio of what Mozart would sound like in a different genre like jazz.

Generative AI involves training a model using large datasets and algorithms, enabling it to produce near original contents that expand on the patterns it has learned. In this article, I will talk about the technologies on which generative AI models are built and how transformers have improved generative AI over the years so stay glued!

Prerequisite.

Readers should have a good understanding of:

Machine learning and
Artificial intelligence.

Encoder-Decoder Architecture.

To properly communicate with AI models, it is important to make them understand the information that is being conveyed and regular human languages would not suffice. This is why the encoder-decoder architecture was developed, it is a neural network sequence-to-sequence architecture that was specifically designed for machine translation, text summarization, question-answering, and other machine learning use cases.

Just as its nomenclature suggests, it has two networks- the encoder and the decoder network, these networks serve as the final gateways for input-output (I/O) operations in the model.

At the encoder part, an input sequence in natural language is converted into its corresponding vector representation. This vector representation attempts to capture all the relevant bits from the input sequence(or prompt).

This vector representation is then fed into the decoder network which generates an output after a series of internal processes.

The Encoder Network.

For an encoder with a Recurrent Neural Network (RNN) internal architecture, each token in an input sequence like The man is going to the bank must first be tokenized, this tokenization process converts the natural language into understandable sets of bits that the model can process. It recurs until the input sequence at the encoder has been completely tokenized.

In most NLP character tokenization adoptions, each token is usually a representation of 4 characters so the example above would be a minimum of 6 tokens.

These tokens are then passed into an embedding layer, this is where they are converted into a single vector representation. The encoder passes the vector representation onto the decoder through a Feedforward neural network.

The Decoder Network.

The encoder and decoder can be built on different architectures and more complex blocks but cases of the same architecture are not unlikely.

The decoder would have its own set of input sequences which would also have been tokenized and embedded. Introducing this sequence of tokens to the decoder would trigger it to attempt a prediction of the next token based on the contextual understanding provided by the encoder, the first prediction is outputted through a softmax output layer.

After the first token is generated, the decoder repeats this prediction process until there are no more tokens left to predict, the first and last predicted tokens are called the <start> and <end> tokens respectively.

The final sequence of tokens is detokenized back into natural language. In a language translation use case, the output generated would be: Der Mann geht zur Bank for a German target language.

Training on Encoder-Decoder Architecture.

Training on an encoder-decoder architecture is more complicated than regular predictive models, having a collection of input/output pairs of the type data from a reference model for imitation is important.

Likewise, the decoder needs to be trained on the correct previously translated token rather than what it is triggered to generate, this technique is called teacher forcing and is a good practice only when you have a credible ground truth.

The decoder network generates the next token based on which token has the highest probability in the softmax layer, there are 2 common algorithms for “choosing” the next token in NLP, they are:

Greedy search: this algorithm chooses the token with the highest conditional probability from the vocabulary as the next generated token. Take a look at the image below, can you tell what sentence the decoder generated? Note that the red saturation decreases as the probability decreases.

If your answer was the last global war is abbreviated as WWII, you are correct. Greedy search is easy to implement but it does not always generate optimal results, a better approach is the beam search algorithm.

Beam search: Instead of deciding off the probability of a single token, the algorithm searches for the sequence or series of tokens with the highest probability so the example above would be chosen among a pool of the war is last abbreviated global WWII as, last war abbreviated is the WWII as global, etc. This approach is more efficient because it reduces computation time and provides some extra level of context.

The encoder-decoder architecture is great because the input sequence and the generated output can be of varying lengths, this is very useful in image/video captioning as well as question-answering use cases. However, this architecture has a bottleneck that has made it obsolete over the years.

Limitations of the Traditional Encoder-Decoder.

When the encoder converts an input sequence into a vector, it compresses all the contextual information into that single vector, this poses a problem when the input sequence is too long. It may prove difficult for both the encoder and decoder because the encoder would struggle with keeping the relevant bits, and the decoder would expend more time on decoding and may lose some relevant bits of information in the process regardless of whether the generated output is short or not. This may lead to inaccuracy of the generated output.

How was this problem tackled without jeopardizing the context of the sequence?

"Attention is all you need"

This is the title of a paper published in 2017 by Vaswani et al, this groundbreaking paper introduced the Transformer model, a novel architecture that revolutionized the field of NLP and became the foundation of the popular Large Language Models (LLMs) that are around today (GPT, PaLM, Bard, etc.) The paper proposes a neural network architecture with an entirely attention-based mechanism instead of the traditional RNNs, click here if you wish to read the paper.

A transformer can be summarized as an encoder-decoder model with an attention mechanism. The image below is from the paper, note how the attention layers are grafted in both encoder and decoder.

Overview of Attention Mechanisms.

Attention mechanism is built to focus on the most important parts of the input sequence and not its entirety. Rather than building a single context vector out of the last hidden state of the encoder, attention mechanism creates shortcuts between the entire input sequence and the context vector.

The weights of these context vectors vary for each output element. Hence, the context vector learns the alignment of the input sequence with the target output by noting the emphasized tokens.

"But how does the model know where to channel its attention?"
It calculates a score known as alignment score which quantifies how much attention should be given to each input. Look at the heatmap below from the Neural Machine Translation by Jointly Learning to Align and Translate paper showing how attention works in a translation use case.

With respect to the previous input sequence: The man is going to the bank, the translation should not pose any problem for regular encoder-decoder models but what if the sequence is longer and has more context?

Take a new input sequence like The man is going to the bank to fish. For regular encoder-decoder models, the generated output in the target language may not align with the contextual meaning of the source language because "bank" now exists with more than one possible translation.

While spotting this distinction is an easy feat for humans, it may be hard for the traditional encoder-decoder, hence, it may produce an output like Der Mann geht zum Bank, um zu fischen instead of Der Mann geht zum Flussufer, um zu fischen, the later is more accurate and would make more sense to a German because *Flussufer means riverbank.
*another translation could be "Ufer" which means "shore".

In the above instance, "bank" and "fish" would have the heaviest weight in an attention mechanism encoder-decoder.

In application, attention layers need to be integrated with the regular encoder-decoder architecture and these layers exist in various types which include:

Generalized attention layer
Self-attention layer
Multi-head attention layer

To know more about layer types, check this article

Conclusion.

The advent of attention mechanisms has revolutionized generative AI, enabling machines to better understand us and generate complex sequences with remarkable precision such that humans are sometimes bewildered by it. Applications across machine translation, question answering, text summarization, and more have benefitted from attention's ability to capture contextual relationships.

As we look to the future, combining attention mechanisms with other architectural innovations holds immense potential for handling even more challenging tasks. Generative AI is just at its best milestone yet and it would continue to get better with more attention-driven applications as machines keep surpassing previous landmarks like never before. It is the responsibility of humans to shape this trajectory for the betterment of life.

If you enjoyed this article, I would appreciate it if you leave a reaction or a comment. Know someone else that would find this article insightful? shares are very much welcome too! I am on Twitter @dvrvsimi and Medium @daraakojede01

Prost!

Creating a Twitter Bot with OpenAI Models in Python: A Beginner’s Guide

Olorundara Akojede (dvrvsimi) — Tue, 06 Jun 2023 15:00:26 +0000

It is no secret that AI is the new disruptive thing in the tech ecosystem and almost all other sectors are looking for innovative ways to adopt automated solutions in their repetitive processes and companies would pay for a seamless and more efficient workflow within their organizations.

Generative Pre-trained Transformers (GPTs) are a type of large language model (LLM) and a prominent framework for generative artificial intelligence, they have been in existence for a while but OpenAi’s chatGPT found a way to make them accessible to even the non-technical population.

In this article, you would learn how to integrate one of OpenAi’s models in a Python program that automates a Twitter bot. Although there are tons of bots on Twitter, it would be cool to build your own as a developer. Who knows? your idea might be featured on the Twitter Dev forum.

The processes would be in easy-to-follow and beginner-friendly steps, let’s go!

Getting Started
Before starting properly, there are a couple of setups that should be put into place and they include:

Access to both Twitter API and OpenAi API.
A text editor.
A platform to periodically run a Python script.

To gain access to Twitter APIs, you should signup on Twitter Developer Portal for dev access. You cannot have a dev account without a Twitter account so make sure to use an account that would be used strictly for automated tweets, this would allow other users to know that your account is a bot account and prevent your account from getting flagged. To learn how to properly set up an automated account, check Automated Account labeling for bots on Twitter’s docs.

You would be asked a couple of questions to know the scope of your API usage and there are various levels of access that can be granted for Twitter API. After a series of changes at Twitter, Elevated access was revoked for new applications, Free access is the lowest tier. It has restricted functions but it should do just fine for the purpose of what you would be building. To know more about Twitter access levels and versions, check the About the Twitter API page.

You can proceed to the Dashboard page after being granted access, on this page, you can name your app and make authentication settings, these settings determine what your generated tokens/secrets can/cannot do. The default environment is usually on Production and can be changed as more developments are made. Remember to store all your tokens in a safe place.

Likewise, look up OpenAi’s API page and create a personal account. The free trial should do for most basic call frequencies and should last for a considerable while, however, if you plan to do some heavy lifting, go ahead to add your preferred subscription.

There are so many platforms for hosting and deploying scripts, WayScript is a good choice and we would get to set it up in a bit.

Preparing the code environment
Now that all the preparatory steps are out of the way, it is time to write the program. There is an endless list of cool features to add to a Twitter bot but you need to preinstall some dependencies that have in-built functions to make code writing efficient. You would build a bot that gives facts about a specific topic based on the user’s request but you would also be able to add a twist!

Tweepy and OpenAi are the required libraries, run pip install tweepy openai in your terminal to install them. Installing dependencies globally is not a good practice, see this article on how to set up virtual environments from your terminal.

What next?
Create a main.py file inside your project folder after you have activated your virtual environment, then import the preinstalled libraries, you should also import the time library which would be used later on, do not install time since it is an in-built Python package.

# importing required libraries
import tweepy
import openai
import time

Now that you have tweepy imported, you can use one of its functions to authenticate your initially generated credentials but before that, create a new .py file for storing your credentials and name it config.py. In the file, assign variables to each credential and save the file.

## config.py
consumer_key = "xxxxxxxxxxxxxxxxxxxxxx"
consumer_secret = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
access_token = "13812xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
access_token_secret = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
openai_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
client_ID = "S1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
client_secret = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

You can now import all your credentials by importing config into your main file.

# importing required libraries
import tweepy
import openai
import time
# note the use of * to universally import config content
from config import *

You cannot access Twitter APIs without authenticating these credentials. OAuthHandler , also known as OAuth1UserHandler in newer versions of tweepy, is a tweepy class for authenticating credentials and it would suffice for this level of access, to know more about other supported authentication methods, check Authentication in Tweepy docs. Set up your OpenAi credential too.

# authorizing with tweepy, note that "auth" is a variable
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
# .set_access_token() is a tweepy method
auth.set_access_token(access_token, access_token_secret)

# creating API object
api = tweepy.API(auth)

# setting up OpenAi key
openai.api_key = openai_key

Another good practice would be to add config.py to a .gitignore file, this would ensure that your credentials are untracked if you push your project to Github.

OpenAi chat models
There are various OpenAi chat models, each with its own syntax. All chat models generate responses with tokens. For every 4 characters, 1 token is expended, longer words cost more tokens so it is good to take that into consideration in order not to exceed your API call limit.

We would be using the text-davinci-003 model(a type of GPT-3.5 model) but the gpt-3.5-turbo is the most capable type of GPT-3.5 model because it is optimized for chat completions and it costs fewer tokens. Read extensively about their chat models on OpenAi's Docs.

Writing Functions
We would need to write a generate_fact() function that would generate a response with our selected chat model from whatever topic the user decides. The Completion class allows us to create an instance of chat completion with the option to tweak some parameters, code below:

#function to geenrate facts about a topic
def generate_fact(topic):
  # play around with the prompt
    prompt = f"you are a grumpy computer programmer, tell a fact about {topic} in a rude and sarcarstic tone"
    response = openai.Completion.create(
    # bear in mind that this engine has a token limit of 4000+ tokens
        engine="text-davinci-003",
        prompt=prompt,
    # note that max_token accomodates both prompt_token and completion_token so provide enough tokens
        max_tokens=1024,
    # set to n=1 for single response and n>1 for multiple responses
        n=1,
        stop=None,
    # temperature ranges from 0.0 to 1.0, nearness to 0 would make the model more deterministic and repititive, nearness to 1 would make it fluid
        temperature=0.8,
    )
    fact = response.choices[0].text.strip()
    return fact

Now that you have created a fact-generating model, you would need to write a handle_mentions() function that handles the mentions of your bot account, you would use Tweepy to listen to specific mentions that would trigger a response.

# function to handle mentions
def handle_mentions():
    mentions = api.mentions_timeline(count=5)  # only retrieve last 5 mentions

    for mention in mentions:
        if mention.in_reply_to_status_id is not None:  # skips tweet replies(optional)
            continue
        if mention.user.screen_name == "bot_account_username":  # skip mentions from self
            continue

        # parse mention_text, it can be "tell me about", anything
        mention_text = mention.text.casefold() # casefold to prevent any error that may arise from different cases
        if "tell a fact about" not in mention_text:
            continue
        topic = mention_text.split("tell a fact about")[1].strip()

        # generate a fact by calling our initisl function
        try:
            fact = generate_fact(topic)
            # post the fact as a reply to the mention
            api.update_status(f"@{mention.user.screen_name} {fact}", in_reply_to_status_id=mention.id)
    # handle OpenAI API errors
        except openai.OpenAIError as e:
            api.update_status(f"@{mention.user.screen_name} sorry, an error occurred while processing your request.", in_reply_to_status_id=mention.id)
    # handle Tweepy errors
        except tweepy.TweepyException as e:
            api.update_status(f"@{mention.user.screen_name} sorry, an error occurred while processing your request.", in_reply_to_status_id=mention.id)
    # Handle other errors that may arise in your code
        except Exception as e:
            api.update_status(f"@{mention.user.screen_name} sorry, an error occurred while processing your request.", in_reply_to_status_id=mention.id)

Remember to replace bot_account_username with your bot account's username, adding error handlers is also a very good Python practice.

To ensure that the program keeps streaming for mentions and sending responses after a specified period of time, you need to add a code block that serves as a loop.

# by adding if __name__ == "__main__":, we can ensure that certain code blocks, handle_mentions() in this case, will only be executed when main.py is run as the main program

if __name__ == "__main__":
    while True:
        try:
            handle_mentions()
        except tweepy.TweepyException as e:
            # handle twitter API errors
            print("an error occurred while handling mentions:", e)
        except Exception as e:
            # handle other errors
            print("an error occurred while handling mentions:", e)
        # wait for 2 minutes before checking for new mentions(reduce the time if traffic increases on your bot account, this is why we imported time)
        time.sleep(120)

NOTE:
When copying the above code blocks, there may be a series of `IndentationError instances so be sure to look out for them.

Deploying the Python Script on WayScript.
Setting up WayScript can be a little challenging but this tutorial video by WayScript thoroughly helps to break the processes down from start to finish.

Conclusion
I have been testing a bot with more functions, take a look at the repository. I would periodically update the README.md with more information.

You want to check more of my articles? you can find them here, you can also connect with me on Twitter.

Great job on building your own Twitter bot with an OpenAI model! As you have learned, Python and OpenAI make it easy to create a powerful bot that can interact with users and provide valuable information. With the techniques you’ve learned, the possibilities are endless for what you can create. Whether it’s a language translator bot, a fact generator, or a reminder bot, the key is to use your imagination and build something that provides value to your audience. So go ahead, build your own Twitter bot, and watch it come to life!