You can check out the completed dashboard at https://uscensus.streamlit.app/. This interactive web app allows users to explore U.S. demographics at the ZIP code or census tract level. All the code can be found on GitHub here.

Let’s dive in!

1. Define The Problem To Solve

Pretty simple, right? But this step is super important. You need to know what problem to solve before exploring any data. In fact, knowing what data you need would be almost impossible without understanding your problem statement.

At work, the problem to solve is usually given to you by a stakeholder. One thing to do is make sure you understand the issue correctly—essentially, the “why” of the problem or question.

There are many practical use cases for building a Census Analysis Dashboard (marketing campaigns, real estate, healthcare, etc. ), but honestly, the “why” for me was so anyone could see some demographic analysis for a specific ZIP code (mainly me).

Write down your project objectives. They'll guide your decisions throughout the development process.

2. Getting that SWEET Data

This is where your journey starts. Well… it depends. If you are at work, you typically have access to all the data you need, and now that you understand the problem statement, it is pretty easy to get the data you need.

But finding data for your projects can be challenging, sometimes even causing you to give up on the project itself.

My journey for demographic data started by going through the typical dataset sites like Kaggle and Amazon, which led me to the World Data Bank. All this data was great, but I wanted to do it by ZIP Code, so it was no good.

Finally, after about 3 hours of all this, I went to Reddit and found a comment mentioning the mother lode of US demographic information: the U.S. Census API.

Census.gov is the most confusing website, and I firmly believe they did this purposefully. This is the moment I thought of giving up on this project. I wanted to do the API but was considering downloading the dataset instead. But after much frustration, I found the simplest way to make an API call. Here it is:

ZIPCODE = '90014'
YEAR = '2022'
BASE_URL = f"https://api.census.gov/data/{YEAR}/acs/acs5"

params = {
        'get': COLUMN_CODE, 
        'key': CENSUS_DATA_API,
        'for': f'zip code tabulation area:{ZIPCODE}'
}

async with aiohttp.ClientSession(connector=aiohttp.TCPConnector()) as session:
   async with session.get(BASE_URL, params=params) as response:
            if response.status == 200:
                data = await response.json()

3. Diving into the Trenches of Data

Once you get the data, it is time to explore and prepare. Usually, there is a data dictionary if you are in an imaginary company; otherwise, you annoy the seniors and SMEs until you understand the data while exploring the dataset with a bunch of print/SELECT statements.

Luckily for us, the US Census provided a data dictionary somewhere here. The only problem is that the dictionary has information of around 28,000 columns. There was no SME here, which meant just using CMD + F to explore the data dictionary.

I faced an issue here; there were so many similar columns and so many others that I thought I should include. This was because my “why“ was not clear enough. I told myself I wanted to see demographic information but did not specify what exactly I wanted to see and why.

Since this is a simple project just for myself, I decided to go with some basic demographic information. I created a JSON file to map the cryptic Census variable codes I needed to human-readable names. Once I had it, getting the data I needed from the API and putting it into pandas data frames was pretty easy. This, by far, took the longest time since I had to gather all the data and clean it correctly for the analysis.

4. Analysis Time

This is pretty straightforward since it involves applying your skills and learning to solve the problem with the data. To start, I wanted to see population distribution by age and sex, employment statistics, and some others. Since I had already done everything in Python so far, I continued building with Pandas.

I am not the best at pandas, so I had to google and read through the documentation a lot to pivot and concat data frames and do some simple analysis.

Side Note: what the hell is pandas.melt()? When did we start massaging data

I hope you understand this is a crucial step driven by our “why” (problem statement) and all the previous decisions. It gets pretty easier the more you practice and tackle complex analysis.

5. Making it look Sexy

Congratulations! You have finished most of the work. I usually take a break, watch a movie, or get a couple of Warzone games in unless I fall short of meeting a deadline.

You have all the analysis, but showing plain Excel without charts these days will not go over well with the stakeholders, especially if you want to get that dough and some praise. So let’s spice it up.

I’m sure there is a better way to handle things, but since that was easier, I created some extra data frames to visualize certain analyses better. I also chose to make it a streamlit app because it is convenient and very accessible to anyone.

One important note: It doesn’t matter what tool you use; how you display the information matters most. Don’t use some cool new visualization chart you found if the person who has to look at it is going to have a hard time understanding. Also, I used Plotly here since it’s cooler than mAtPlOtLiB. Fight me.

Your Turn: Dive In or Contribute!

Now that you've seen the process of building a data analysis project from start to finish, it's your turn to get your hands dirty! Start thinking about your own data analysis project right now and get on with it.

If not, here are some ways you can practice and contribute:

1. Clone the Census Analysis Dashboard repository and run it locally.

2. Explore the code and see how the concepts we discussed are implemented.

3. Think of a feature you'd like to add or an improvement you could make. Maybe additional visualizations? Or analysis of trends over time?

4. Create a fork of the repository, make your changes, and submit a pull request. This is a great way to get real-world experience with collaborative coding!

Remember, the key is to start building, keep learning, and don't be afraid to ask questions or seek help.

That is it from me! I hope this exploration was helpful in some way!

If you found value in this article, please share it with someone who might also benefit from it. Your support helps spread knowledge and inspires more content like this. Let's keep the conversation going—share your thoughts and experiences below!

What is LangChain?

Let's start with a proper definition, shall we?

LangChain: An open-source framework designed to facilitate the development of applications using Large Language Models (LLMs). It provides a standardized interface for chains, prompts, and integration of external data sources and tools with LLMs.

In simpler terms, LangChain is like a Swiss Army knife for AI applications. You reach for it when you want your LLM to do more than generate witty comebacks. In my opinion, the best feature is that you can easily plug and play almost any LLMs into your applications with LangChain.

The Building Blocks of LangChain

LangChain operates on three main components. Let's break them down:

1. LLMs (Large Language Models): Artificial intelligence models trained on vast amounts of text data to understand and generate human-like text. They are the brains of the operation. We'll be using Groq because, apparently, good things can be free.

2. Prompts: Structured input provided to an LLM to guide its output in a specific direction. In our context, conversation starters are like the small talk of the AI world, but hopefully more enjoyable.

3. Output Parsers: Components that process and structure the raw output from an LLM into a more usable format. As you explore LangChain, you will also encounter many other components.

4. Agents: Advanced constructs that use LLMs to determine actions and tools to use. This is one feature that can make your applications more versatile but since it is a bit more advanced, we won’t be covering it today.

Check out the video if you want more detailed information about how it works with proper code breakdown in Jupyter.

Setting Up Your Development Environment

Before we dive into coding, let's prepare our workspace. After all, a poorly set environment is as helpful as a chocolate teapot. Once in a virtual environment,

1. Install the required packages:

pip install langchain langchain-groq streamlit python-dotenv

2. Get your API keys:

   • For LangSmith (optional): LangSmith is used for testing and debugging LLM applications, but we can also use it to monitor how our chains work to better understand them. Visit LangSmith Settings to get your API key.

   • For Groq (our LLM provider): Head to Groq Console and get your FREE API key; you will have access to multiple open-source LLM models.

   Pro tip: Keep these keys secret. Treat them like your diary from middle school – not for public consumption.

3. Set up your environment variables:

from dotenv import load_dotenv

load_dotenv()

This loads your API keys from a .env file.

LangChain's Core Components

Let's examine the three primary components we'll be working with. In our project, we'll use Groq's implementation:

from langchain_groq import ChatGroq

llm = ChatGroq(model='llama3-8b-8192')

LangChain provides the ChatPromptTemplate for creating dynamic prompts:

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
       ("system", "You are a helpful assistant with a slight sarcastic edge."),
       ("user", "{user_input}")
])

We'll use the StrOutputParser for simplicity:

from langchain_core.output_parsers import StrOutputParser

output_parser = StrOutputParser()

A chain in LangChain combines these components to create a processing pipeline. Let's construct a basic chain:

chain = prompt | llm | output_parser
response = chain.invoke({"user_input": "Explain quantum computing in simple terms."})
print(response)

This chain takes user input, formats it with the prompt, processes it through the LLM, and then parses the output.

Crafting Your First Chain:

Now, let's see how these components work together to create a basic chain.

from langchain_groq import ChatGroq
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Initialize the LLM
llm = ChatGroq(model='llama3-8b-8192')

# Create a prompt template
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with a slightly sarcastic sense of humor."),
    ("user", "{user_input}")
])

# Construct the chain
chain = prompt | llm | StrOutputParser()

# Invoke the chain
response = chain.invoke({"user_input": "Explain quantum computing like I'm five."})

print(response)

Let's break this down again:

1. We initialize our LLM (ChatGroq) with a specific model.

2. We create a ChatPromptTemplate, which structures our input to the LLM.

3. We build our chain using the `|` operator, which is LangChain's way of saying "pipe this into that".

4. Finally, we invoke the chain with our input.

Adding Memory: Because Even AIs Need to Remember

Now, let's give our chatbot a memory. After all, what's the point of artificial intelligence if it can't remember that you hate pineapple on pizza?

from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory

# Initialize chat history
msgs = ChatMessageHistory()

# Create a new prompt template with chat history
prompt_with_history = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with a slightly sarcastic sense of humor."),
    ("placeholder", "{chat_history}"),
    ("user", "{query}")
])

# Construct the chain with history
chain_with_history = RunnableWithMessageHistory(
    prompt_with_history | llm | StrOutputParser(),
    lambda session_id: msgs,
    input_messages_key="query",
    history_messages_key="chat_history"
)

# Have a conversation
config = {"configurable": {"session_id": "sarcastic_chat"}}
response1 = chain_with_history.invoke({"query": "Tell me a joke about programming."}, config=config)

print(response1)

response2 = chain_with_history.invoke({"query": "Now explain the joke."}, config=config)

print(response2)

Here's what's happening:

1. We create a ChatMessageHistory to store our conversation.

2. We update our prompt template to include a placeholder for chat history.

3. We use RunnableWithMessageHistory to create a chain that maintains a conversation state.

4. We invoke the chain multiple times, and it remembers previous interactions.

Now, it can maintain context across multiple interactions. I’d recommend watching the video since it will drive home these concepts in a more practical and fun approach.

Building a Streamlit App: Bringing Your Chatbot to Life

Finally, let's wrap our chatbot in a Streamlit app for a more user-friendly interface. After all, not everyone appreciates the raw beauty of a command line:

import streamlit as st
from langchain_groq import ChatGroq
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import StreamlitChatMessageHistory

st.title("🤖 Sarcastic AI Assistant")

# Model selection and temperature setting
models = ["llama3-70b-8192", "llama3-8b-8192", "mixtral-8x7b-32768", "gemma-7b-it"]

model = st.selectbox("Choose your LLM model:", models)
temperature = st.slider("Set the sarcasm level:", 0.0, 2.0, 1.0, 0.1)

# Initialize LLM
llm = ChatGroq(model=model, temperature=temperature)

# Set up prompt and chain
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with a slightly sarcastic sense of humor."),
    ("placeholder", "{chat_history}"),
    ("user", "{query}")
])

chain = prompt | llm | StrOutputParser()

# Set up chat history
msgs = StreamlitChatMessageHistory()

# Create chain with history
chain_with_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: msgs,
    input_messages_key="query",
    history_messages_key="chat_history"
)

# Chat interface
if "messages" not in st.session_state:
    st.session_state.messages = []

for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

if prompt := st.chat_input("Ask me anything, if you dare..."):
    st.session_state.messages.append({"role": "user", "content": prompt})

    with st.chat_message("user"):
        st.markdown(prompt)

    with st.chat_message("assistant"):
        config = {"configurable": {"session_id": "sarcastic_chat"}}
        response = chain_with_history.invoke({"query": prompt}, config=config)
        st.markdown(response)

    st.session_state.messages.append({"role": "assistant", "content": response})

st.sidebar.write(f"Current model: {llm.model_name}")

This Streamlit app does the following:

1. Provides a user interface for selecting the LLM model and adjusting the "sarcasm level" (temperature).

2. Initializes the LLM and sets up the chain with history.

3. Creates a chat interface where users can interact with the AI.

4. Displays the conversation history and the current model in use.

To run this masterpiece, save it as a .py file and run:

streamlit run your_app_name.py

And voilà! You now have a web app to chat with a slightly sarcastic AI. It's like talking to a tech support rep with fewer sighs and eye-rolls.

Conclusion

Congratulations! You've successfully navigated the basics of LangChain and created a functional, slightly sarcastic chatbot. You've also learned about LLMs, prompts, chains, and how to implement memory in your AI applications. Plus, you've wrapped it all in a Streamlit app.

Remember, this is just scratching the surface of what LangChain can do. There's a whole world of advanced features waiting for you to explore, like connecting to databases, using different LLMs, and even giving your AI the ability to use external tools. We will cover some of them in the future.

Use your newfound LangChain skills wisely. Maybe don't use them to automate your social media presence or to write your wedding vows—unless, of course, you want your significant other to question your life choices.

Happy coding, and may your error messages be few! 💻

That is it from me! I hope this exploration was helpful in some way! What are your thoughts on the Langchain? What are some topics you might want me to cover next?

If you found value in this article, please share it with someone who might also benefit from it. Your support helps spread knowledge and inspires more content like this. Don’t forget to like this article and — share your thoughts and experiences below! :)

Initial Reception and Funding

When announced, the R1 was received well by the general public and many people compared it with the Humane AI Pin. They raised around $30 million on their funding round with more than 100k pre-orders. It seemed like Rabbit pioneered with LAM and people were excited about the device. And I honestly liked the idea of the R1 better than the AI Pin, although both would be better as an app on my phone or something similar.

Trouble started brewing when the product started getting into the hands of the people. The device's retro design and unique features garnered interest from tech enthusiasts but many users criticized the Rabbit R1 for its unreliable performance, inaccurate answers, poor battery life, and steep learning curve. A lot of the tech reviewers on YouTube found the product not review-worthy.

Subscribe now

The Large Action Model (LAM) Ordeal

Rabbit Incorporation markets the Rabbit R1 as utilizing a "Large Action Model" (LAM), an advanced AI system capable of learning and executing app-based tasks on behalf of the user, inferring and modeling human actions on computer applications, performing the actions reliably and quickly. This is supposed to be a step ahead of the “Large Language Models” (LLMs) that we know of and are more powerful.

“LAM‘s modeling approach is rooted in imitation, or learning by demonstration: it observes a human using the interface and aims to reliably replicate the process, even if the interface is presented differently or slightly changed. Instead of having a black-box model uncontrollably outputting actions and adapting to the application during inference, LAM‘s "recipe" is more observable.” - Rabbit Inc.

However, this term appears more of a marketing gimmick than a genuine technological innovation. The LAM is described as a system that learns how an app works to navigate it on the user's behalf, but in practice, it functions more like a basic voice assistant with limited capabilities. Android Authority’s Mishaal Rahman downloaded Rabbit’s launcher APK onto a Google Pixel 6A and ran the whole thing on an Android.

The application looks like an LLM wrapper that uses Playwright to automate browser-based tasks (Rabbit founder Jesse Lyu has confirmed that they use Playwright but has not explained how). In other words, it uses ChatGPT and Perplexity AI with hardcoded scripts. This causes a lot of data privacy concerns and can have inaccurate location tracking. This also makes it inconsistent in performing the tasks it promises to do extremely well; so when any of the apps change their UI ever-so-slightly, which is a lot, the r1 will definitely break.

And honestly, creating an AI system to perform tasks on a website or app isn't that hard. For example, you can feed an LLM the HTML of a website and make it interactive (I have done a barebones version of this with a Chrome chatbot extension) although it might be real slow and have many data privacy concerns.

Anyways that seems like the least of their problems…

Coffeezilla's Investigation

Coffeezilla, a YouTuber known for investigating scams, has alleged that Rabbit Incorporation is built on hype. The company was previously named Cyber Manufacturing Co and raised $6 million for an NFT project called GAMA, which promised a carbon-negative cryptocurrency but failed to deliver. He claims that the funds raised for GAMA may have been used to develop Rabbit R1 and investors in GAMA have not been refunded. Even more, he highlighted discrepancies in the company's financials and the overhyped nature of the Rabbit R1.

Now Rabbit Incorporation denies the allegations, stating that the GAMA project was open-sourced and given back to the community. They claim there is no way to refund NFTs unless the owner agrees to burn them (which makes no sense unless these NFTs are worthless). The company asserts that the funds raised for GAMA were used solely for that project and that the project was not abandoned.

Coffezilla has also claimed to have seen the source for the rabbit os and echoed the speculations of others. He has also spoken to someone from the company who states that the “LAM” is nothing more than a marketing term.

Discussions on platforms like Reddit reflect a divided opinion, with some users defending the potential of the Rabbit R1 and others echoing the scam allegations and expressing disappointment with the product's performance. The YouTube community mainly dislikes the sloppy product and the allegations of misusing funds raised for the GAMA project could have legal implications if proven true. Investors in GAMA may seek legal recourse if they believe they were defrauded.

The Rabbit R1, while an intriguing concept, appears to be, at the very least, an unfinished product with significant limitations. "Large Action Model" (LAM) seems more of a marketing term than a genuine technological advancement. The device's performance issues, coupled with the controversies surrounding its parent company, raise serious questions about its viability and the integrity of its founders.

One key takeaway from this should be that consumers should be cautious about investing in products based on future promises and evaluate them based on current functionality.

That is it from me! I hope this exploration was helpful in some way! What are your thoughts on the Rabbit r1? What are some similar AI trends you noticed?

If you found value in this article, please share it with someone who might also benefit from it. Your support helps spread knowledge and inspires more content like this. Don’t forget to like this article and — share your thoughts and experiences below! :)

This article provides an essential technical backdrop, how LLMs affect our environment, the ongoing efforts to mitigate these effects, and how policies and personal actions can contribute to more sustainable AI practices.

What are Large Language Models?

ChatGPT, Claude, Gemini, and yes BERT (Bidirectional Encoder Representations from Transformers) are all Large Language Models but what are they and why are they so energy extensive?

Large Language Models (LLMs) are a type of artificial intelligence system that is trained on vast amounts of text data, allowing them to generate human-like responses, understand and process natural language, and perform a wide range of language-related tasks. It is like looking for patterns in the texts to figure out what to say back to you, and these texts are huge amounts of articles/books/posts/etc., also called training data.

Essentially, LLMs work by using neural networks to identify patterns and relationships in the training data, which can then be used to generate new text, answer questions, translate between languages, and more. These neural networks have layers of algorithms, each designed to recognize different elements of human language, from simple grammar to complex idioms and mainly context.

The training process involves repeatedly adjusting these layers to minimize errors in output, requiring multiple iterations across potentially billions of parameters. For example, GPT-3 has about 175 billion parameters. It is trained on about 45TB of text data from different datasets. This, right now, is a medium to small LLM. The more ‘better’ a model is the more complex and resource-intensive it gets.

This computation is not only data-intensive (remember the huge amounts of training data?) but also requires a lot of electrical power, typically executed on specialized hardware like GPUs (Graphics Processing Units) or TPUs (Tensor Processing Units). You can already see the storage, training/processing, and operational costs that it can incur.

Understanding the Environmental Impacts of LLMs

Each phase of the LLMs has its own footprint:

Training Impacts:

The training process requires considerable computational resources, typically involving multiple high-powered GPUs or TPUs that run continuously for weeks or even months. This consumes large amounts of electricity, contributing to the carbon footprint of LLMs. All these AI companies boast about how amazing and powerful their new model is, and how much information it can process but they rarely discuss the computational and environmental cost of said models.

For example, students from the University of Copenhagen developed a tool to predict the carbon footprint of algorithms and found that one training session with GPT-3 uses the same amount of energy that is needed by 126 homes in Denmark annually.

Another famous study by researchers at the University of Massachusetts, Amherst, performed an analysis of the carbon footprint of transformer models.

They found that a simple transformer with around 213 million parameters emits almost 5 times the lifetime emissions of the average American car or about 315 round trip flights from New York to San Francisco.

Just to put things in perspective, let’s see what an actual model’s carbon footprint is like. A simple 213-parameter model produces 626,155 lbs of CO2. Claude 3 is rumored to have 500 billion parameters. Let’s assume a linear scaling (for our simple brain to comprehend), which would be an increase of 2348x.

So 626,155 x 2348 is a whopping 1,469,456,540 or 1.5 Billion lbs of CO2 for a model like Claude 3 that we are using nowadays.

This is of course due to the energy-intensive nature of the training process, which involves running the model through billions of computations. But why companies are shy about revealing such numbers?

Storage and Operational Impacts:

The data centers that power LLMs are also a major source of environmental impact. These facilities require large amounts of energy for cooling, ventilation, and other operational needs. They also generate e-waste from the constant upgrading and replacement of hardware.

A recent study at the University of California, Riverside, revealed the significant water footprint of LLMs. Microsoft used approximately 700,000 liters of freshwater during GPT-3’s training in its data centers which is equal to how much water is needed to make 320 Tesla vehicles.

I know it says during the training process but the model also uses a lot of water in the inference process (when you are using it). For a brief exchange involving 20-50 queries, the water usage is comparable to a 500 ml bottle. Given its billions of users, the cumulative water footprint for processing these interactions is quite significant. Even if we take 1 billion users that is 500 million liters of water; it can fill up around 200 Olympic-sized swimming pools.

Moreover, the storage and hosting of LLMs, which can be terabytes in size, requires dedicated server infrastructure, further adding to the environmental footprint.

In response to Bloomberg asking OpenAI about the sustainability concern, they had this to say:

‘OpenAI runs on Azure, and we work closely with Microsoft’s team to improve efficiency and our footprint to run large language models.‘

Also found these discussions on the OpenAI Community

Hardware and Other Impacts:

LLMs also require significant hardware resources, such as high-performance GPUs, storage, and memory. I was reading this article when I read the author’s update that they had assumed ChatGPT runs on 16 GPUs, but in fact, it runs on more than 29,000 GPUs. The manufacturing, transportation, and eventual disposal of these hardware can also have environmental impacts.

This raises concerns about environmental justice, as the resource-intensive nature of these models may disproportionately affect marginalized communities and developing regions that have less access to clean energy and sustainable infrastructure.

How to be more sustainable with AI?

As the concerns around the environmental impacts of LLMs have grown, there have been various efforts and advancements to make these models more sustainable. But I can’t lie, I do not feel like these efforts are enough. I am not convinced that the speed of these advancements can keep up with the exponential growth of LLMs and AI.

Some of the key areas that we need to start or continue focusing on:

1. What can companies do?

Companies are investing heavily to reduce the energy consumption of AI tools and models. Some are exploring using carbon offsets to counterbalance the emissions generated by their LLMs. Microsoft, Google, Apple, and Meta all have pledged to be carbon-neutral and net-zero. Google developed tensor processing units (TPUs) that are more energy-efficient than traditional GPUs.

But there is still a need for awareness of how much impact AI has on the Earth publicly. Companies need to be transparent with footprints and work with the public to make Earth more sustainable. Not only that, they need to implement renewable and recycling programs.

This is not just about being green in the public eye; it’s about pushing the sustainability agenda to the forefront and setting industry standards.

2. What can developers do?

There is already an emphasis on researching and developing more efficient models. Techniques such as transfer learning, pruning, quantization, knowledge distillation, etc. are being employed to make models more efficient without sacrificing performance.

Developers should prioritize building and contributing to open-source projects focused on sustainable AI practices. More training in eco-conscious programming can also be embedded in developer education.

3. What can policymakers do?

Policymaking plays a crucial role in guiding the development and implementation of AI technologies sustainably. Policies that incentivize energy-efficient AI, set emissions targets, and encourage the use of renewable energy can help drive companies to adopt more sustainable practices.

The EU’s Green Deal includes specific provisions for digital sector sustainability, aiming to significantly reduce its carbon and electronic waste footprint. The AI Act is the first-ever legal framework on AI, which addresses the risks of AI. These are a good start but we need more, especially in the US. We need to enact policies that require tech companies to report and reduce their carbon footprints. Transparency in energy consumption should be mandatory, not optional.

4. What can YOU do?

Of course, as individuals, raising awareness and supporting green AI initiatives is crucial, but it starts with being well-informed. Understanding the environmental implications of AI use and sharing this knowledge can catalyze collective action toward sustainable practices. Being vocal and using our influence matters significantly.

Additionally, on the technical side, using concise prompts and selecting models that are efficient in processing can reduce computational demands. By streamlining the complexity and length of prompts and reducing unnecessary interactions, we can significantly cut down on the computational resources needed. This not only conserves energy but also aligns with more sustainable AI usage practices.

Conclusion

While LLMs offer unprecedented capabilities, their environmental impact cannot be overlooked. It’s clear that bold steps are needed from all stakeholders—companies, developers, policymakers, and users alike. The path to sustainable AI is complex and challenging, but with concerted effort and innovation, it’s possible to harness the benefits of AI without compromising our planet.

That is it from me! I hope this exploration was helpful in some way! What are your thoughts on sustainable AI? What are some trends you noticed?

If you found value in this article, please share it with someone who might also benefit from it. Your support helps spread knowledge and inspires more content like this. Let's keep the conversation going—share your thoughts and experiences below!

What are Generator functions?

Any function that uses yield instead of return is a generator function. Simple right? but what does yield do? The yield keyword here produces a sequence of values over time, instead of returning a single value. For example, instead of returning a list of items or a whole dataset, it produces a sequence of items from a list or rows from the dataset at a time.

This allows generator functions to produce values on the fly and pauses their state between outputs, making them memory-efficient and performance-friendly.

This has nothing to do with the trending and cool Generative AI that's been capturing everyone's attention; we are talking about functions that help us streamline our data processing tasks with elegance and efficiency.

How does it do that?

A normal function runs through all the lines of codes within it and returns a value. The generator function, however, returns an iterator, or in this case, a generator object. This produces only one value at a time so no other values will be stored. When the next() function is used on the object, the next value is produced.

Basically, we can loop through something without storing everyone all at once with the help of generators. You can learn more in detail about this here.

Let’s try to understand it from an example:

def infinite_counter():
    count = 0
    while True:
        yield count
        count += 1

# Using the generator
for number in infinite_counter():
    print(number)
    if number >= 10:  # Stop at 10 to keep things sane!
        break

This is a simple infinite counter. Here's what's happening:

• infinite_counter defines a generator function that starts counting from 0.

• Inside an infinite loop, it yields the current count, then increments it.

• In the for loop, the function is called so it produces numbers from 0 upwards.

• The loop prints each number, and we've added a break condition to stop the loop after it prints 10, preventing an actual infinite loop.

This example shows the power of generators to handle potentially infinite sequences in a memory-efficient way, yielding one item at a time!

Generative Expressions:

Generator functions are just one way to create generator objects. Another way is Generator Expressions. They are just like list comprehensions but for generators; you can convert a list comprehension into a generator expression by replacing the square brackets [] with parentheses ().

squares = (x**2 for x in range(10))

This generator expression creates a sequence of squared numbers, showcasing the elegance and simplicity of using generative functions for on-the-fly data processing.

Generator Functions in Data Processing

Generative functions are the unsung heroes of memory management. Their ability to yield data incrementally means they can process information piece by piece, rather than loading everything into memory at once. This approach is not just about being resourceful; it's a necessity when dealing with datasets that can go across gigabytes or even terabytes.

Generative functions are incredibly versatile, fitting a wide range of scenarios beyond the basics:

• Real-time data streams: Perfect for processing live data feeds, where data is continuous and potentially infinite.

• Large files: Useful for reading and processing data without the need to load everything into memory simultaneously.

• Data transformation pipelines: Implement stages of data transformation where each function passes its output to the next, efficiently handling data at each step.

Let’s run through some examples because the author is not happy with the length of this article so far.

Example 1: Processing large files

Let’s say you want to filter out specific entries from a file based on certain criteria, such as error messages in a log file:

def filter_errors(log_file):
    with open(log_file, 'r') as file:
        for line in file:
            if "ERROR" in line:
                yield line.strip()

This function goes through each line of the log, yielding only those that contain error messages, showing us how generative functions can be used for real-time data filtering.

Example 2: Data Loading and Preprocessing

Generators are particularly useful in machine learning for data loading and preprocessing. Libraries like TensorFlow and PyTorch support data loaders that can be used to stream data from disks in batches using generator functions.

TensorFlow extensively uses the concept of generators through its tf.data.Dataset API, which allows for efficient data loading, preprocessing, and augmentation on the fly during model training.

The from_generator method allows you to create a Dataset from a Python generator. Here, TensorFlow uses the generator function indirectly to stream data:

import tensorflow as tf

dataset = tf.data.Dataset.from_generator(
    generator=load_data,
    output_types=(tf.float32, tf.float32),
    args=(arg1, arg2,)
)

dataset = dataset.batch(32)  # Batching data for training

Example 3: Principles in Pandas

Pandas offers functionality that aligns with the principles of generators, useful when dealing with large datasets that might not fit into memory.

For row-wise iteration, iterrows and itertuples can be used, though it's important to note that these methods may not always be the most efficient way to iterate over a data frame.

import pandas as pd

df = pd.DataFrame({'a': range(10), 'b': range(10, 20)})

# iterrows example
for index, row in df.iterrows():
    print(row['a'], row['b'])

# itertuples example
for row in df.itertuples(index=False):
    print(row.a, row.b)

Pro-Tip: Pandas' read_csv function allows processing large CSV files in manageable chunks, a method particularly beneficial for large datasets. When you use the chunksize parameter, the function will return an iterator object.

for chunk in pd.read_csv('large_file.csv', chunksize=100000):
    # Process each chunk here
    process(chunk)

Example 4: Web Crawling with Generators

Scrapy, an asynchronous web scraping framework, uses generators and coroutines to handle web requests and responses efficiently. Here's a simplified example of a Scrapy spider that uses generators to crawl web pages:

import scrapy

class ErrorLogSpider(scrapy.Spider):
    name = "error_log_spider"
    start_urls = ['http://example.com/logs']

    def parse(self, response):
        # Extract log page URLs
        log_urls = response.css('a::attr(href)').getall()
        for url in log_urls:
            yield response.follow(url, self.parse_log)

    def parse_log(self, response):
        # Extract error messages
        for error_msg in response.css('.error::text').getall():
            yield {'error': error_msg}

We start from a main page, follow links to log pages, and extract error messages, all while using generators to facilitate efficient data extraction and processing in web crawling tasks.

Example 5: Related concepts in other libraries

This concept of deferring computation and efficiently managing resources is a common thread that ties together various Python libraries. Libraries like Numpy leverage iterators for creating arrays from iterable sequences, optimizing memory usage in data manipulation. Similarly, PySpark employs lazy evaluation to efficiently process big data across distributed systems, executing transformations only when an action requires the result, thereby optimizing computation and resource utilization.

Understanding and leveraging these principles allows data professionals to handle larger datasets, speed up data processing, and write more efficient and scalable Python code.

Hopefully, these examples illustrate the power of generators, iterators, and related concepts, highlighting their importance in efficient data processing and analysis in various contexts. Whether you're processing streams of real-time data or chipping away at massive datasets, embracing generative functions can elevate your data handling to new heights.

That is it from me! Have you used similar techniques before, or do you see new opportunities to apply them in your work? I hope this exploration was helpful in some way!

If you found value in this article, please share it with someone who might also benefit from it. Your support helps spread knowledge and inspires more content like this. Let's keep the conversation going—share your thoughts and experiences below!

BSA has emerged as a crucial tool for marketers, content creators, and data enthusiasts. But what does it really mean, and why is it gaining such traction?

I came across BSA through Conan O’Brien’s podcast, “Conan O’Brien Needs A Friend.”, and I decided that I want to make my first written article on this topic. So critique me on how I’m doing?

Anyway, if you don’t know Conan or haven’t seen his work, I highly recommend checking him out. But… you definitely don’t know me, so check me out too. :P

Conan O’Brien is not just a household name; he’s a seasoned comedian, writer, and producer known for his quick wit and innovative comedy. He used to work as a writer for The Simpsons and IS my favorite talk show host, who is also now podcasting. Every year on his podcast, they have a ‘State of the Podcast’ session similar to how the United States of America holds their ‘State of the Union’, where they kinda analyze and see how the podcast is doing overall.

Why Brand Safety Analysis?

• Targeted Advertising: BSA enables brands to place their advertisements more strategically, ensuring creators align with the content’s values and reach the desired audience.

• Content Strategy: It offers content creators insight into how their thematic choices or language use might influence potential brand partnerships.

• Consumer Insights: By understanding what content resonates with audiences, brands can tailor their marketing strategies more effectively.

The Essence of Brand Safety Analysis

At its core, Brand Safety Analysis is an evaluative process used by brands to ensure that a platform’s content aligns with their values and public image. Now this is not done by every company. When you start out creating content and getting sponsorships, it is very unlikely that you come across BSA. This is because the smaller companies do not really care about your brand when they set you up with sponsorship “codes” that they track to know how much sales are coming from your audience.

But as you get bigger and get approached by bigger companies for partnerships, BSA plays a huge role. If a company is partnering with you, and you do not align with their views/values, it can hurt both parties. This analysis acts like a compatibility check for potential partnerships between advertisers and content creators. In the case of Conan’s podcast, a detailed BSA provided insights into various content dimensions that advertisers scrutinize, such as:

• Obscenity and Profanity: Quantifying the use of language that might be deemed inappropriate.

• Adult and Sexual Content: Assessing references to sexual content, innuendos, or adult themes.

• Hate Speech and Aggression: Identifying content that could be perceived as discriminatory or promoting violence.

• Illegal Drug References: Highlighting mentions of illegal substances or activities.

• Military Conflict: Analyzing discussions related to wars or military actions.

• Violation of Human Rights: Scrutinizing content for potential endorsements of human rights violations.

The challenge here, particularly for a data nerd, lies in the methodology. How do we develop algorithms capable of understanding humor, sarcasm, and the nuanced dynamics of conversation? Conan’s content, renowned for its comedic genius and sarcasm, brings to light the intricate challenge of quantifying content properly.

The Future of Content and Brand Synergy

Brand Safety Analysis is not just the simple goal of avoiding controversy. It’s about creating a harmonious relationship between content and advertising, benefiting brands, creators, and consumers. As we delve deeper into the digital content era, the significance of Brand Safety Analysis only grows, opening new avenues for exploration and understanding; especially in the field of data.

For data professionals, marketers, and tech enthusiasts, the journey into the realm of BSA promises a blend of challenges and opportunities, all aimed at enhancing the digital content landscape.

That is it from me! What’s your take on Brand Safety Analysis? Have you encountered similar methodologies in your work, or do you see potential applications in your field? Hope you enjoyed this article and was helpful in some way! I would really appreciate it if you would like, comment, or share this article with someone who might find some value.

Check out the video that talks about BSA from Conan that inspired me to write my first medium article :)