Day: October 11, 2024

CSS gradients have been so long that there’s no need to rehash what they are and how to use them. You have surely encountered them at some point in your front-end journey, and if you follow me, you also know that I use them all the time. I use them for CSS patterns, nice CSS decorations, and even CSS loaders. But even so, gradients have a tough syntax that can get very complicated very quickly if you’re not paying attention.

In this article, we are not going to make complex stuff with CSS gradients. Instead, we’re keeping things simple and I am going to walk through all of the incredible things we can do with just one gradient.

Only one gradient? In this case, reading the doc should be enough, no?

No, not really. Follow along and you will see that gradients are easy at their most basic, but are super powerful if we push them — or in this case, just one — to their limits.

CSS patterns

One of the first things you learn with gradients is that we can establish repeatable patterns with them. You’ve probably seen some examples of checkerboard patterns in the wild. That’s something we can quickly pull off with a single CSS gradient. In this case, we can reach for the repeating-conic-gradient() function:

background: 
  repeating-conic-gradient(#000 0 25%, #fff 0 50%) 
  0 / 100px 100px;

A more verbose version of that without the background shorthand:

background-image: repeating-conic-gradient(#000 0 25%, #fff 0 50%);
background-size: 100px 100px;

Either way, the result is the same:

Pretty simple so far, right? You have two colors that you can easily swap out for other colors, plus the background-size property to control the square shapes.

If we change the color stops — where one color stops and another starts — we get another cool pattern based on triangles:

background: 
  repeating-conic-gradient(#000 0 12.5%, #fff 0 25%) 
  0 / 100px 100px;

If you compare the CSS for the two demos we’ve seen so far, you’ll see that all I did was divide the color stops in half, 25% to 12.5% and 50% to 25%.

Another one? Let’s go!

This time I’m working with CSS variables. I like this because variables make it infinitely easier to configure the gradients by updating a few values without actually touching the syntax. The calculation is a little more complex this time around, as it relies on trigonometric functions to get accurate values.

I know what you are thinking: Trigonometry? That sounds hard. That is certainly true, particularly if you’re new to CSS gradients. A good way to visualize the pattern is to disable the repetition using the no-repeat value. This isolates the pattern to one instance so that you clearly see what’s getting repeated. The following example declares background-image without a background-size so you can see the tile that repeats and better understand each gradient:

I want to avoid a step-by-step tutorial for each and every example we’re covering so that I can share lots more examples without getting lost in the weeds. Instead, I’ll point you to three articles you can refer to that get into those weeds and allow you to pick apart our examples.

• How to create background patterns using CSS & conic-gradient (Verpex blog)
• Learn CSS radial-gradient by Building Background Patterns (freeCodeCamp)
• Background Patterns, Simplified by Conic Gradients (Ana Tudor)

I’ll also encourage you to open my online collection of patterns for even more examples. Most of the examples are made with multiple gradients, but there are plenty that use only one. The goal of this article is to learn a few “single gradient” tricks — but the ultimate goal is to be able to combine as many gradients as possible to create cool stuff!

Grid lines

Let’s start with the following example:

You might claim that this belongs under “Patterns” — and you are right! But let’s make it more flexible by adding variables for controlling the thickness and the total number of cells. In other words, let’s create a grid!

.grid-lines {
  --n: 3; /* number of rows */
  --m: 5; /* number of columns */
  --s: 80px; /* control the size of the grid */
  --t: 2px; /* the thickness */

  width: calc(var(--m)*var(--s) + var(--t));
  height: calc(var(--n)*var(--s) + var(--t));
  background:  
    conic-gradient(from 90deg at var(--t) var(--t), #0000 25%, #000 0)
      0 0/var(--s) var(--s);
}

First of all, let’s isolate the gradient to better understand the repetition (like we did in the previous section).

One repetition will give us a horizontal and a vertical line. The size of the gradient is controlled by the variable --s, so we define the width and height as a multiplier to get as many lines as we want to establish the grid pattern.

What’s with “+ var(--t)” in the equation?

The grid winds up like this without it:

We are missing lines at the right and the bottom which is logical considering the gradient we are using. To fix this, the gradient needs to be repeated one more time, but not at full size. For this reason, we are adding the thickness to the equation to have enough space for the extra repetition and the get the missing lines.

And what about a responsive configuration where the number of columns depends on the available space? We remove the --m variable and define the width like this:

width: calc(round(down, 100%, var(--s)) + var(--t));

Instead of multiplying things, we use the round() function to tell the browser to make the element full width and round the value to be a multiple of --s. In other words, the browser will find the multiplier for us!

Resize the below and see how the grid behaves:

In the future, we will also be able to do this with the calc-size() function:

width: calc-size(auto, round(down, size, var(--s)) + var(--t));

Using calc-size() is essentially the same as the last example, but instead of using 100% we consider auto to be the width value. It’s still early to adopt such syntax. You can test the result in the latest version of Chrome at the time of this writing:

Dashed lines

Let’s try something different: vertical (or horizontal) dashed lines where we can control everything.

.dashed-lines {
  --t: 2px;  /* thickness of the lines */
  --g: 50px; /* gap between lines */
  --s: 12px; /* size of the dashes */
  
  background:
    conic-gradient(at var(--t) 50%, #0000 75%, #000 0)
    var(--g)/calc(var(--g) + var(--t)) var(--s);
}

Can you figure out how it works? Here is a figure with hints:

Try creating the horizontal version on your own. Here’s a demo that shows how I tackled it, but give it a try before peeking at it.

What about a grid with dashed lines — is that possible?

Yes, but using two gradients instead of one. The code is published over at my collection of CSS shapes. And yes, the responsive behavior is there as well!

Rainbow gradient

How would you create the following gradient in CSS?

You might start by picking as many color values along the rainbow as you can, then chaining them in a linear-gradient:

linear-gradient(90deg, red, yellow, green, /* etc. */, red);

Good idea, but it won’t get you all the way there. Plus, it requires you to juggle color stops and fuss with them until you get things just right.

There is a simpler solution. We can accomplish this with just one color!

background: linear-gradient(90deg in hsl longer hue, red 0 0);

I know, the syntax looks strange if you’re seeing the new color interpolation for the first time.

If I only declare this:

background: linear-gradient(90deg, red, red); /* or (90deg, red 0 0) */

…the browser creates a gradient that goes from red to red… red everywhere! When we set this “in hsl“, we’re changing the color space used for the interpolation between the colors:

background: linear-gradient(90deg in hsl, red, red);

Now, the browser will create a gradient that goes from red to red… this time using the HSL color space rather than the default RGB color space. Nothing changes visually… still see red everywhere.

The longer hue bit is what’s interesting. When we’re in the HSL color space, the hue channel’s value is an angle unit (e.g., 25deg). You can see the HSL color space as a circle where the angle defines the position of the color within that circle.

Since it’s a circle, we can move between two points using a “short” path or “long” path.

If we consider the same point (red in our case) it means that the “short” path contains only red and the “long” path runs into all the colors as it traverses the color space.

Adam Argyle published a very detailed guide on high-definition colors in CSS. I recommend reading it because you will find all the features we’re covering (this section in particular) to get more context on how everything comes together.

We can use the same technique to create a color wheel using a conic-gradient:

background: conic-gradient(in hsl longer hue,red 0 0);

And while we are on the topic of CSS colors, I shared another fun trick that allows you to define an array of color values… yes, in CSS! And it only uses a single gradient as well.

Hover effects

Let’s do another exercise, this time working with hover effects. We tend to rely on pseudo-elements and extra elements when it comes to things like applying underlines and overlays on hover, and we tend to forget that gradients are equally, if not more, effective for getting the job done.

Case in point. Let’s use a single gradient to form an underline that slides on hover:

h3 {
  background: 
    linear-gradient(#1095c1 0 0) no-repeat
    var(--p,0) 100%/var(--p, 0) .1em;
  transition: 0.4s, background-position 0s;
}

h3:hover {
  --p: 100%;
}

You likely would have used a pseudo-element for this, right? I think that’s probably how most people would approach it. It’s a viable solution but I find that using a gradient instead results in cleaner, more concise CSS.

You might be interested in another article I wrote for CSS-Tricks where I use the same technique to create a wide variety of cool hover effects.

CSS shapes

Creating shapes with gradients is my favorite thing to do in CSS. I’ve been doing it for what feels like forever and love it so much that I published a “Modern Guide for Making CSS Shapes” over at Smashing Magazine earlier this year. I hope you check it out not only to learn more tricks but to see just how many shapes we can create with such a small amount of code — many that rely only on a single CSS gradient.

Some of my favorites include zig-zag borders:

…and “scooped” corners:

…as well as sparkles:

…and common icons like the plus sign:

I won’t get into the details of creating these shapes to avoid making this article long and boring. Read the guide and visit my CSS Shape collection and you’ll have everything you need to make these, and more!

Border image tricks

Let’s do one more before we put a cap on this. Earlier this year, I discovered how awesome the CSS border-image property is for creating different kinds of decorations and shapes. And guess what? border-image limits us to using just one gradient, so we are obliged to follow that restriction.

Again, just one gradient and we get a bunch of fun results. I’ll drop in my favorites like I did in the last section. Starting with a gradient overlay:

We can use this technique for a full-width background:

…as well as heading dividers:

…and even ribbons:

All of these have traditionally required hacks, magic numbers, and other workarounds. It’s awesome to see modern CSS making things more effortless. Go read my article on this topic to find all the interesting stuff you can make using border-image.

Wrapping up

I hope you enjoyed this collection of “single-gradient” tricks. Most folks I know tend to use gradients to create, well, gradients. But as we’ve seen, they are more powerful and can be used for lots of other things, like drawing shapes.

I like to add a reminder at the end of an article like this that the goal is not to restrict yourself to using one gradient. You can use more! The goal is to get a better handle on how gradients work and push them in interesting ways — that, in turn, makes us better at writing CSS. So, go forth and experiment — I’d love to see what you make!

CSS Tricks That Use Only One Gradient originally published on CSS-Tricks, which is part of the DigitalOcean family. You should get the newsletter.

Open-source LLMS, owing to their comparable performance with advanced proprietary LLMs, have been gaining immense popularity lately. Open-source LLMs are free to use, and you can easily modify their source code or fine-tune them on your systems.

Alibaba's Qwen and Meta's Llama series of models are two major players in the open source LLM arena. In this article, we will compare the performance of Qwen 2.5-72b and Llama 3.1-70b models for zero-shot text classification and summarization.

By the end of this article, you will have a rough idea of which model to use for your NLP tasks.

So, lets begin without ado.

We will call the Hugging Face inference API to access the Qwen and LLama models. In addition, we will need the rouge-score library to calculate ROUGE scores for text summarization tasks. The script below installs the required libraries for this article.

!pip install huggingface_hub==0.24.7
!pip install rouge-score
!pip install --upgrade openpyxl
!pip install pandas openpyxl

The script below installs the required libraries.

from huggingface_hub import InferenceClient
import os
import pandas as pd
from rouge_score import rouge_scorer
from sklearn.metrics import accuracy_score
from collections import defaultdict

To access models via the Hugging Face inference API, you will need your Hugging Face User Access tokens.

Next, create a client object for the corresponding model using the InferenceClient class from the huggingface_hub library.
You must pass the Hugging Face model path and the access token to the InferenceClientclass constructor.

The script below creates model clients for Qwen 2.5-72b and Llama 3.1-70b models.

hf_token = os.environ.get('HF_TOKEN')

#qwen 2.5 endpoint
#https://huggingface.co/Qwen/Qwen2.5-72B-Instruct
qwen_model_client = InferenceClient(
    "Qwen/Qwen2.5-72B-Instruct",
    token=hf_token
)

#Llama 3.1 endpoint
#https://huggingface.co/meta-llama/Llama-3.1-70B-Instruct
llama_model_client = InferenceClient(
    "meta-llama/Llama-3.1-70B-Instruct",
    token=hf_token
)

To get a response from the model, you can call the chat_completion() method and pass a list of system and user messages to the messages attribute of the method.

The script below defines the make_prediction() method, which accepts the model client, the system role prompt, and the user query and generates a response using the model client.

def make_prediction(model, system_role, user_query):

    response = model.chat_completion(
    messages=[{"role": "system", "content": system_role},
        {"role": "user", "content": user_query}],
    max_tokens=10,
    )

    return response.choices[0].message.content

Let's first generate a dummy response using the Qwen 2.5-72b.

system_role = "Assign positive, negative, or neutral sentiment to the movie review. Return only a single word in your response"
user_query = "I like this movie a lot"
make_prediction(qwen_model_client,
               system_role,
               user_query)

Output:

'positive'

The above output shows that the Qwen model generates the expected response.

Let's try the Llama 3.1-70b model now.

system_role = "Assign positive, negative, or neutral sentiment to the movie review. Return only a single word in your response"
user_query = "I hate this movie a lot"
make_prediction(llama_model_client,
               system_role,
               user_query)

Output:

'negative'

And voila, the Llama also makes correct predictions.

In the following two sections, we will compare the performance of the two models on custom datasets. We see how the two models fare for zero-shot text classification and summarization.

For text classification, we will use the Twitter US Airline Sentiment, which consists of positive, negative, and neutral tweets for various US airlines.

The following script imports the dataset into a Pandas DataFrame.

## Dataset download link
## https://www.kaggle.com/datasets/crowdflower/twitter-airline-sentiment?select=Tweets.csv

dataset = pd.read_csv(r"D:\Datasets\Tweets.csv")
dataset.head()

Output:

We will preprocess our dataset and select 100 tweets (34 neutral and 33 each for positive and negative sentiments).

# Remove rows where 'airline_sentiment' or 'text' are NaN
dataset = dataset.dropna(subset=['airline_sentiment', 'text'])

# Remove rows where 'airline_sentiment' or 'text' are empty strings
dataset = dataset[(dataset['airline_sentiment'].str.strip() != '') & (dataset['text'].str.strip() != '')]

# Filter the DataFrame for each sentiment
neutral_df = dataset[dataset['airline_sentiment'] == 'neutral']
positive_df = dataset[dataset['airline_sentiment'] == 'positive']
negative_df = dataset[dataset['airline_sentiment'] == 'negative']

# Randomly sample records from each sentiment
neutral_sample = neutral_df.sample(n=34)
positive_sample = positive_df.sample(n=33)
negative_sample = negative_df.sample(n=33)

# Concatenate the samples into one DataFrame
dataset = pd.concat([neutral_sample, positive_sample, negative_sample])

# Reset index if needed
dataset.reset_index(drop=True, inplace=True)

# print value counts
print(dataset["airline_sentiment"].value_counts())

Output:

airline_sentiment
neutral     34
positive    33
negative    33
Name: count, dtype: int64

Next, we will define the predict_sentiment() function, which accepts the model client, the system prompt, and the user query and generates a model response.

def predict_sentiment(model, system_role, user_query):

    response = model.chat_completion(
    messages=[{"role": "system", "content": system_role},
        {"role": "user", "content": user_query}],
    max_tokens=10,
    )

    return response.choices[0].message.content

In the next step, we will iterate through the 100 tweets in our dataset and predict sentiment for each tweet using the Qwen 2.5-72b and Llama 3.1-70b models, as shown in the following script.

models = {
    "qwen2.5-72b": qwen_model_client,
    "llama3.1-70b": llama_model_client
}

tweets_list = dataset["text"].tolist()
all_sentiments = []
exceptions = 0

for i, tweet in enumerate(tweets_list, 1):
    for model_name, model_client in models.items():
        try:
            print(f"Processing tweet {i} with model {model_name}")

            system_role = "You are an expert in annotating tweets with positive, negative, and neutral emotions"

            user_query = (
                f"What is the sentiment expressed in the following tweet about an airline? "
                f"Select sentiment value from positive, negative, or neutral. "
                f"Return only the sentiment value in small letters.\n\n"
                f"tweet: {tweet}"
            )

            sentiment_value = predict_sentiment(model_client, system_role, user_query)
            all_sentiments.append({
                'tweet_id': i,
                'model': model_name,
                'sentiment': sentiment_value
            })
            print(i, model_name, sentiment_value)

        except Exception as e:
            print("===================")
            print("Exception occurred with model:", model_name, "| Tweet:", i, "| Error:", e)
            exceptions += 1

print("Total exception count:", exceptions)

Output:

Finally, we will convert the predictions for both models into a Pandas Dataframe. We will then fetch the predictions for the individual models and compare them with the actual sentiment values in the datasets to calculate accuracy.

# Convert results to DataFrame and calculate accuracy for each model
results_df = pd.DataFrame(all_sentiments)

for model_name in models.keys():
    model_results = results_df[results_df['model'] == model_name]
    accuracy = accuracy_score(model_results['sentiment'], dataset["airline_sentiment"].iloc[:len(model_results)])
    print(f"Accuracy for {model_name}: {accuracy}")

Output:

Accuracy for qwen2.5-72b: 0.8
Accuracy for llama3.1-70b: 0.77

The above output shows that the Qwen 2.5-72b model achieves 80% accuracy while the Llama-3.1-70b model achieves 77% accuracy. Qwen 2.5-72b model wins the battle for zero-shot text classification.

Let's now see which model performs better for zero-shot text summarization.

We will use the News Articles Dataset to summarise text using the Qwen and Llama models.

The following script imports the dataset into Pandas DataFrame.

# Kaggle dataset download link
# https://github.com/reddzzz/DataScience_FP/blob/main/dataset.xlsx

dataset = pd.read_excel(r"D:\Datasets\dataset.xlsx")
dataset = dataset.sample(frac=1)
print(dataset.shape)
dataset.head()

Output:

Next, we will check the average number of characters in all summaries. We will use this number as output tokens in the LLM model response.

dataset['summary_length'] = dataset['human_summary'].apply(len)
average_length = dataset['summary_length'].mean()
print(f"Average length of summaries: {average_length:.2f} characters")

Output:

Average length of summaries: 1168.78 characters

We will define the generate_summary() helper method, which takes in the model client, the system prompt, and the user query as parameters and returns the model client response.

def generate_summary(model, system_role, user_query):

    response = model.chat_completion(
    messages=[{"role": "system", "content": system_role},
        {"role": "user", "content": user_query}],
    max_tokens=1200,
    )

    return response.choices[0].message.content

We will also define the calculate_rouge helper method that takes in actual and predicted summaries as parameters and returns ROUGE scores.

# Function to calculate ROUGE scores
def calculate_rouge(reference, candidate):
    scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
    scores = scorer.score(reference, candidate)
    return {key: value.fmeasure for key, value in scores.items()}

Finally, we will iterate through the first 20 articles in the dataset and summarize them using the Qwen 2.5-72b and Llama 3.1-70b models. We will use the generate_summary() function to generate the summary of the model and then use the calculate_rouge() method to calculate ROUGE scores for the prediction.

We create a Pandas DataFrame that contains ROUGE scores for all article summaries generated via the Qwen 2.5-72b and Llama 3.1-70b models.

models = {"qwen2.5-72b": qwen_model_client,
          "llama3.1-70b": llama_model_client}

results = []

i = 0
for _, row in dataset[:20].iterrows():
    article = row['content']
    human_summary = row['human_summary']

    i = i + 1

    for model_name, model_client in models.items():

        print(f"Summarizing article {i} with model {model_name}")
        system_role = "You are an expert in creating summaries from text"
        user_query = f"Summarize the following article in 1150 characters. The summary should look like human created:\n\n{article}\n\nSummary:"

        generated_summary = generate_summary(model_client, system_role, user_query)
        rouge_scores = calculate_rouge(human_summary, generated_summary)

        results.append({
            'model': model_name,
            'article_id': row.id,
            'generated_summary': generated_summary,
            'rouge1': rouge_scores['rouge1'],
            'rouge2': rouge_scores['rouge2'],
            'rougeL': rouge_scores['rougeL']
        })

# Create a DataFrame with results
results_df = pd.DataFrame(results)

Output:

Finally, we can take the average ROUGE scores of all the article summaries to compare the two models.

average_scores = results_df.groupby('model')[['rouge1', 'rouge2', 'rougeL']].mean()
average_scores_sorted = average_scores.sort_values(by='rouge1', ascending=False)
print("Average ROUGE scores by model:")
average_scores_sorted.head()

Output:

The Qwen model wins here as well for all ROUGE scores.

Open-source LLMs are quickly catching up with proprietary models. Qwen 2.5-72B has already surpassed GPT-4 turbo, introduced at the beginning of this year.

In this article, you saw a comparison between Qwen 2.5-72b and Llama 3.1-70b models for zero-shot text classification and summarization. The Qwen model performs better than Llama on both tasks.

I encourage you to use the Qwen model for text generation tasks like Chatbot development and share your work with us.

Large Language Models (LLMs) can significantly improve your SEO success and at the same time lower your workload. Here are the Dos and Don'ts of using ChatGPT for SEO.

What's the best way to integrate AI into keyword research? How to create engaging content with ChatGPT? And what other ways are there to streamline your SEO with LLMs?

Here are my 2 cents on the topic as an SEO consultant with 15 years experience. The following guide offers some (maybe unexpected) ways to integrate AI into your workflows, while at the same time improving quality and reducing hours.

One often overlooked way to boost your SEO is to use ChatGPT for troubleshooting. It is excellent at helping you fix technical errors pretty much anything that might affect the Core Vitals in Google Search Console or lower your score on the web.dev checker. Got a weird CLS- or LCP-error affecting your WordPress site? Need to fix someone else's PHP code on a 9-year-old stand-alone page? Talk it through with ChatGPT and you might be surprised how easy some fixes come these days.

I previously used to spend countless hours looking through old threads on different message boards when troubleshooting. Now it's one short chat with my assistant, and I usually find more elegant fixes than before too. To clarify: ChatGPT does not "fix" anything by itself. But it assists you in locating the source of an error and resolving it. Of course, you have to provide the context, goal, and, if applicable, relevant code snippets.

Keyword research is still a mostly "manual" task and I use quotation marks here because it has relied on various tools since the beginning of SEO such as the Google Keyword Planner, list generators, suggestion-tools, etc. In my opinion, AI hasn't really impacted the initial steps and strategies of keyword research yet. However, ChatGPT and other LLMs are good at identifying things you might have overlooked.

When I start to compile my keyword list, I show every column of the list separately to an LLM and ask it to suggest additions. This helps me to identify expressions that I might not have considered. The rest of the process is mostly as before: I use a tool from pre-AI times to automatically compile all possible combinations of my keyword columns. After checking the search volume for all those phrases, I am left with a list of potentially useful keywords. This list I show to an LLM once more, just to double check that I didn't miss anything obvious.

There is a variety of plugins for keyword research with ChatGPT available, but in my experience, they don't contribute much more than the standard version (4o at the time of writing).

Using LLMs for creating written content is a controversial topic on the one hand, it can be difficult (if not impossible) to identify texts written by AI; on the other hand, AI is often applied so unprofessionally, that it is painfully obvious when a text was written this way. Even worse, we have seen content like that rank much higher than it should for a while. Google tried to address the issue with a core update to its algorithm earlier this year, but there is still lack of consensus among SEO experts as to how successful this was.

In my experience, LLMs can be helpful for phrasing if you provide the right input, structure, context, and ideas. Don't try to have the chatbot come up with the content for the text, it will most likely spit out something bland. Give it clear instructions and it will provide fitting phrasing for almost every context, or at least be able to suggest (sometimes better) alternative formulations that you can use to improve your own writing. Moreover, it's best not to try to make an LLM write an entire landing page at once. Better take it step by step and only ask for single parts/slides/paragraphs/headlines etc. Also: Claude is much better at this than ChatGPT at the moment.

If there is one thing I am certain about regarding Google's search algorithm, then it is that it absolutely loves relevant, unique photos and illustrations. DALL-E is great for generating images that just perfectly fit the content of your site, and it also makes it much easier to create your own infographics.

Please note that DALL-E couldn't create an entire infographic, as it is not meant to accurately visualize data, and it has serious troubles spelling anything correctly that is more than a few characters or words. For such things, we still rely on image editing software. But DALL-E can provide individual elements, icons, frames, etc. and ChatGPT is helpful for bouncing ideas for data visualization.

If I use a photo generated by AI 1:1 on a website, I always adjust the dimensions and filename and delete the metadata just to be sure I don't make it too easy for bots to identify it as generated content. You're not sure how to delete a file's metadata? Ask ChatGPT! ;)

I'd estimate that AI tools have improved the quality of my work in SEO by at least 20% and slightly reduced my hours at the same time.

Other ways of successfully integrating AI into SEO are definitely on the horizon, and I'd advise all SEO professionals to familiarize themselves with the latest tools and to stay up to date. In my opinion, AI is today approximately where the Internet was in 1998, and the landscape will most likely continue to change rapidly. Hence, what works today might not work tomorrow bear that in mind when developing your long-term SEO strategies. Stay flexible, keep learning, and be prepared to adapt as AI continue to evolve.

As a content writer in the digital marketing space, I spend a lot of time breaking down industry terms, concepts, and strategies, some of which can be more confusing or difficult to grasp than others.

However, I have also found that some terms, including “B2B2C marketing,” might seem to be overly complicated at first, but turn out to be much easier to understand once you investigate them.

In this post, I’ll guide you through what B2B2C marketing is and how it works, as well as provide a few examples of popular and effective B2B2C marketing strategies.

Table of Contents

• What is B2B2C marketing?
• Why B2B2C Marketing Works
• How B2B2C Marketing Works
• 3 Effective B2B2C Marketing Strategies

Importantly, B2B2C marketing is distinct from B2B or B2C marketing, in which businesses sell exclusively to other businesses or directly to consumers.

B2B2C marketing is actually incredibly common, and most of us engage with businesses utilizing this model on a regular basis.

In fact, B2B2C marketing has been around for ages but has grown increasingly prevalent over the years as technological innovation has made it easier and more beneficial for businesses to collaborate.

Now that I’ve provided you with a basic definition of B2B2C marketing, let’s look at exactly why — and how — it works and explore some real-world examples.

Why B2B2C Marketing Works

Personally, I have seen B2B2C marketing take many forms and be used in various contexts across industries.

In many cases, these have been simple arrangements between two businesses, in which the underlying strategies and mutually beneficial nature of the partnerships were incredibly straightforward.

And in others, the inner workings and processes have been considerably more intricate, sometimes including a product manufacturer, global distributor, and hundreds of independent retail organizations operating around the world.

However, in virtually every example I’ve encountered, B2B2C marketing strategies tend to follow the same basic set of rules and target similar outcomes. Here are some of the ways that this model is beneficial for businesses.

Shared Benefits of Partnership and Collaboration

The first thing to understand is that B2B2C marketing is essentially a partnership or collaboration between businesses.

These partnerships are typically formed by recognizing that each business has something the other needs or can benefit from.

In most cases, the first business has a particular product, and the second, intermediary business has access to consumers who would be interested in buying that product.

Put simply, when B2B2C marketing is utilized effectively, everybody wins.

Elevated Brand Awareness and Growth

It’s also important to note that the benefits of B2B2C marketing often go far beyond increasing sales.

For one, collaborative content creation and marketing efforts between businesses help build brand awareness and grow each company’s consumer base.

Increased Access to Consumer Data and Insights

Additionally, in many cases the first business will gain access to valuable consumer data and insights, allowing them to better identify and understand their target audience. This in turn helps them provide more personalized experiences.

How B2B2C Marketing Works

Now that I’ve given a general description of why B2B2C marketing works and how it benefits businesses, I’d like to highlight a few examples of companies that use this model.

The examples I’m about to share will demonstrate how B2B2C marketing strategies can vary depending on the product and/or industry.

B2B2C Marketing Strategy Example 1: Frito-Lay

Frito-Lay is a great company to start with because it offers one of the oldest, most basic iterations of B2B2C marketing.

As a manufacturer of popular snacks, Frito-Lay partners with grocery stores around the world, which act as intermediaries that buy, market, and sell its products directly to consumers.

One common aspect of B2B2C marketing to keep in mind as we go through these examples is that consumers will always be aware of the partnership.

In this example, when I go to the grocery store to buy my favorite chips, I understand that I am buying the chips from the store, but also that the chips originated from and were manufactured at one of Frito-Lay’s facilities.

B2B2C Marketing Strategy Example 2: Instacart

Sticking with groceries as a product category, Instacart is another, more modern example of B2B2C marketing in action. In this case, however, the grocery store is the first business and Instacart is the intermediary.

More specifically, if I own and operate a grocery store, I am limited to selling my products to consumers who walk into the physical location to purchase groceries.

But by partnering with a delivery service like Instacart, I now have a way to sell my products to people in their home, and without the need to worry about the logistics involved with food delivery.

B2B2C Marketing Strategy Example 3: Apple

Moving on to the tech industry, Apple is an excellent example to look at for a few reasons. For one, it engages in different B2B2C strategies related to both hardware and digital services.

Secondly, Apple is an example of a company whose business model consists of B2B, B2C, and B2B2C all at once.

In terms of hardware, Apple sells its iPhones to telecommunications companies, such as Verizon and T-Mobile, who then sell the iPhones directly to consumers (B2B2C). At the same time, Apple also sells its products directly to consumers at its own stores and on its website (B2C).

Regarding digital services, Apple provides its marketplace, the App Store, to software developers who can then sell their mobile applications to consumers (B2B2C).

Meanwhile, Apple also sells its own software solutions and platforms, such as Apple Business Manager, directly to business owners to support their operations (B2B).

B2B2C Marketing Strategy Example 4: Amazon

Amazon runs one of the largest and most successful B2B2C marketing operations in the world.

By providing an ecommerce marketplace, along with warehouse, customer support, and delivery services, businesses and manufacturers across industries gain the ability to sell their products to a wider range of consumers than they would normally have access to.

It’s also worth mentioning that, like Apple, Amazon also manufactures and sells its own products to consumers on its website (B2C), while also producing and distributing its own software solutions to businesses (B2B).

By this point, I hope you’ve gained a better understanding of what B2B2C marketing is and how it works in different industries and contexts.

Now, I want to examine a few specific strategies that can help businesses maximize the impact of their B2B2C marketing efforts.

3 Effective B2B2C Marketing Strategies

From what I’ve seen, the most successful B2B2C marketing strategies are those in which both businesses lean into the collaborative element of their partnership, finding creating ways for each to benefit while optimizing the experiences and satisfaction of the end consumer.

For example, I once worked for a small clothing company with a uniquely talented creative team and exclusive access to influential brand ambassadors. But they also had extremely limited capital, ecommerce capabilities, and access to consumers.

By partnering with a much larger, more established fashion brand, they were able to execute a collaborative campaign and get their products in front of a larger audience — all while providing their partner with high-quality creative content and a valuable influencer co-sign to help revive the brand’s image.

Here are just a few effective B2B2C marketing strategies that emphasize collaboration and mutually beneficial outcomes.

1. Collaborative Marketing Campaigns

Fostering brand awareness is often important to both businesses within a B2B2C marketing partnership.

As such, broadcasting your collaboration via creative advertising campaigns can be a great way to call attention to both brands as well as their specific services and product offerings.

For example, influencer marketing has become an increasingly effective way to reach online consumers and bring brands into the spotlight.

Whether it’s launched on social media or in the form of a television or streaming service advertisement, engaging a celebrity to promote the collaboration between brands will help ensure the partnership doesn’t fly under the radar.

Best for: B2B2C partnerships in which both companies have a significant consumer-facing element. For instance, if Samsung and Verizon collaborate on a campaign advertising a new mobile device combined with a service promotion, both businesses can increase sales based on the same campaign.

Pro tip: Using unified marketing software like Marketing Hub can be a big help here as you collaborate on campaigns.

2. Referral Programs

While by no means a new concept, establishing a referral program remains one of the most effective ways for businesses to collaborate to each party’s benefit.

In the case of B2B2C marketing specifically, this can allow an intermediary to be compensated for the sale of the first business’s product rather than merely supporting them or providing access to consumers.

Referral programs can be rolled out in a variety of ways, but in many cases, it’s as simple as agreeing on a fair commission for the intermediary based on each individual sale of a product or service.

As an example, if I own a SaaS company and partner with an online marketplace to sell my solutions, it might make sense to offer a 10% commission on each sale, particularly considering the sale wouldn’t have been possible without their services.

Best for: Businesses selling high-ticket items or services, such as SaaS and FinTech companies. In B2B2C marketing, referral programs tend to work best when the products being sold are more expensive.

Put simply, high-ticket items provide a better incentive for the intermediary, and the financial impact of the referral arrangement for both parties is much easier to estimate and track.

3. Personalization Based on Data Sharing

Finally, in many B2B2C partnerships, data sharing is one of the most important and valuable components of the relationship.

This is primarily because it allows businesses to gather and analyze consumer insights to create more personalized experiences, ensuring both a customer’s immediate satisfaction and making it easier to market similar products to them in the future.

For example, if I run an ecommerce platform that hosts and sells a company’s products, evaluating data related to that company’s consumer base will tell me more about who they are and what they like.

I can then use this information to offer those consumers additional products that align with their past purchases, behaviors, and preferences.

Best for: Businesses across industries that have advanced data management capabilities and processes. Personalization is an excellent tool, but there are certain instances in which data sharing is not a part of the B2B2C marketing partnership, or in which a business may not have the level of digital maturity or marketing software needed to make sufficient use of consumer data.

B2B2C marketing is a versatile solution.

The main thing I’ve learned from this post — and I hope you have too — is that B2B2C marketing is an incredibly diverse business model. It can take on virtually limitless forms and be implemented via a wide range of strategies.

The bottom line is that B2B2C marketing is a versatile solution for addressing a variety of needs. While the specific way it’s implemented will depend on both the businesses’ capabilities and what they’re looking to accomplish, it definitely has something to offer companies at all stages of their journey.

In this third and final part of a three-part series, we’re taking a more streamlined approach to an application that supports vision-language (VLM) and text-to-speech (TTS). This time, we’ll use different models that are designed for all three modalities — images or videos, text, and audio( including speech-to-text) — in one model. These “any-to-any” models make things easier by allowing us to avoid switching between models.

Specifically, we’ll focus on two powerful models: Reka and Gemini 1.5 Pro.

Both models take things to the next level compared to the tools we used earlier. They eliminate the need for separate speech recognition models, providing a unified solution for multimodal tasks. With this in mind, our goal in this article is to explore how Reka and Gemini simplify building advanced applications that handle images, text, and audio all at once.

The architecture of multimodal models has evolved to enable seamless handling of various inputs, including text, images, and audio, among others. Traditional models often require separate components for each modality, but recent advancements in “any-to-any” models like Next-GPT or 4M allow developers to build systems that process multiple modalities within a unified architecture.

Gato, for instance, utilizes a 1.2 billion parameter decoder-only transformer architecture with 24 layers, embedding sizes of 2048 and a hidden size of 8196 in its feed-forward layers. This structure is optimized for general tasks across various inputs, but it still relies on extensive task-specific fine-tuning.

GPT-4o, on the other hand, takes a different approach with training on multiple media types within a single architecture. This means it’s a single model trained to handle a variety of inputs (e.g., text, images, code) without the need for separate systems for each. This training method allows for smoother task-switching and better generalization across tasks.

Similarly, CoDi employs a multistage training scheme to handle a linear number of tasks while supporting input-output combinations across different modalities. CoDi’s architecture builds a shared multimodal space, enabling synchronized generation for intertwined modalities like video and audio, making it ideal for more dynamic multimedia tasks.

Most “any-to-any” models, including the ones we’ve discussed, rely on a few key concepts to handle different tasks and inputs smoothly:

• Shared representation space
  These models convert different types of inputs — text, images, audio — into a common feature space. Text is encoded into vectors, images into feature maps, and audio into spectrograms or embeddings. This shared space allows the model to process various inputs in a unified way.
• Attention mechanisms
  Attention layers help the model focus on the most relevant parts of each input, whether it’s understanding the text, generating captions from images, or interpreting audio.
• Cross-modal interaction
  In many models, inputs from one modality (e.g., text) can guide the generation or interpretation of another modality (e.g., images), allowing for more integrated and cohesive outputs.
• Pre-training and fine-tuning
  Models are typically pre-trained on large datasets across different types of data and then fine-tuned for specific tasks, enhancing their performance in real-world applications.

Reka is an AI research company that helps developers build powerful applications by offering models for a range of tasks. These tasks include generating text from videos and images, translating speech, and answering complex questions from long multimodal documents. Reka’s models can even write and execute code, providing flexible, real-world solutions for developers.

These are the three main models Reka offers:

1. Reka Core
   A 67-billion-parameter multimodal language model designed for complex tasks. It supports inputs like images, videos, and texts while excelling in advanced reasoning and coding.
2. Reka Flash
   A faster model with a 21-billion-parameter, designed for flexibility and rapid performance in multimodal settings.
3. Reka Edge (PDF)
   A smaller 7-billion-parameter model was built for on-device and low-latency applications, making it efficient for local use and local or latency-sensitive applications.

Reka’s models can be fine-tuned and deployed securely, whether on the cloud, on-premises, or even on-device. Let’s start by testing Reka’s capabilities directly through its playground. This allows us to experiment with its multimodal features without writing any code, providing a hands-on way to see how the models handle various tasks, such as image and video comprehension.

Alright, we’ll kick things off by uploading an image of a diagram outline of the PaliGemma architecture and ask Reka for a detailed explanation.

Can you provide a more detailed explanation of this image?

Here’s what we get from Reka Core:

“This image is a schematic representation of a machine-learning model named PaliGemma. The model appears to be designed for multimodal input, combining both image and text data. At the top, there are two input sources: ‘Image Input’ and ‘Text Input’. The image input is processed by a ‘SigLIP Image Encoder’, which likely stands for a specific type of image encoding technique. The output of this encoder is then subjected to a ‘Linear Projection’, which is a common step in machine learning to transform data into a lower-dimensional space. The text input is directly fed into the model. Both the projected image data and the text input are then concatenated into ‘Concatenated Tokens’, which are then processed by a component labeled ‘Gemma’. The final output of the model is ‘Text Output’, which suggests that the model is designed to generate text based on the input data.”

It’s a clear and detailed breakdown of the PaliGemma architecture. The model accurately identifies image and text inputs, the SigLIP image encoder, and the linear projection step. It also grasps how the image and text inputs are combined and processed to generate text output. I should admit that the response is quite neat, offering a solid explanation of the architecture.

Let’s try a video input instead. We’ll upload the video about Genny, a software, and ask a question to see how well Reka Core handles video comprehension.

What is this video about?

“This video is a screen recording of a group of friends discussing their plans for the weekend.”

Well, it’s not a good answer compared to what LLaVA gave us in the previous article. Now let’s try a longer video, but with the Reka Flash model. The video is about a TTS model called Parler TTS. Instead of asking what the video is about, let’s prompt it like this:

I’m an AI developer, and I’m not sure how this TTS model can help me in my projects. Can you explain how I can use it or what it’s useful for?

Reka Flash generates a solid answer this time:

“Of course! This TTS (Text-to-Speech) model can be incredibly useful for developers, especially those working on projects that involve creating more human-like interactions or providing audio feedback to users. Here are some ways you can leverage this TTS model in your projects:

1. Accessibility: TTS models can greatly enhance the accessibility of your applications for users with visual impairments or reading difficulties. By providing spoken feedback or narrating content, you can make your applications more inclusive
2. Voice Assistants: You can integrate this TTS model into voice assistants or chatbots, allowing them to generate more natural-sounding responses. This can improve user experience and make interactions with your bots more engaging.
3. Multimedia Applications: This TTS model can be used in multimedia applications, such as e-books, educational tools, or games, to provide spoken narration or instructions. This can make the content more engaging and easier to understand.
4. Audio Notifications: You can use the TTS model to generate audio notifications for your applications, providing users with spoken alerts or reminders. This can be particularly useful for users who may not always have their screens visible.
5. Language Learning: The TTS model can be used in language learning applications to provide users with correct pronunciation and intonation. It can also generate spoken feedback or narrate lessons, making the learning process more immersive.
6. Audio Books: You can use the TTS model to generate audio books, allowing users to listen to written content instead of reading it. This can be especially helpful for users who prefer auditory learning or have difficulty reading.
7. Explainer Videos: The TTS model can be used to generate voiceovers for explainer videos, providing users with spoken narration that explains the content on the screen. This can make the content more engaging and easier to understand.
8. Audio Feedback: You can use the TTS model to generate audio feedback for users in your applications, such as confirming actions, providing instructions, or giving feedback on their performance. This can make the interactions more natural and intuitive.

In summary, the TTS model can be a valuable tool for developers looking to create more human-like interactions, improve accessibility, and enhance the user experience in various applications.”

It’s a good answer that’s informative and quite practical for developers. Let’s compare what happens when we try the Reka Edge model with a PDF input titled “Meta AI — Responsible Use Guide” (PDF).

As an AI developer, how can I ensure that I am following the responsible AI guidelines outlined in this document?

“To ensure that your use of AI aligns with the principles outlined in this guide, you can follow these steps and best practices:

1. Familiarize yourself with the principles of responsible AI, such as transparency, accountability, and user empowerment, as outlined in the guide.
2. Understand the potential impacts of AI on users and society, and be aware of the risks and challenges associated with the development and deployment of AI systems.
3. Embrace an iterative model-development mindset, continuously striving for improvement and learning from feedback and errors.
4. Build a responsible AI ecosystem by working with partners, experts, and communities to develop and share best practices, tools, and benchmarking resources.
5. Follow the guidelines and best practices outlined in the guide for each stage of model development, from data collection and preparation to fine-tuning, evaluation, and deployment.
6. Consider the specific use case and requirements for your AI system, and tailor your approach accordingly.
7. Regularly monitor and evaluate the performance and safety of your AI system and make adjustments as needed to ensure it aligns with the principles outlined in the guide.
8. Be transparent and accountable in your interactions with users and stakeholders, and be open to feedback and suggestions for improvement.
9. Stay informed about the latest developments and research in the field of AI, and be prepared to adapt your approach as needed to address new challenges and opportunities.
10. Follow the specific guidelines and best practices outlined in the addendum for Code Llama, such as defining content policies, evaluating and benchmarking models, and addressing input- and output-level risks.”

Reka Edge’s answer is quite thorough and detailed, too!

If you want to dive into coding, start by creating a Reka account and getting an API key. Then you can follow along with this notebook. Try out their Python SDK, and make sure to explore the different models available. It’s a great way to see how these tools work under the hood!

Gemini 1.5, developed by Google DeepMind, is designed to handle complex tasks efficiently, thanks to the new Mixture-of-Experts (MoE) system. MoE is like packing several specialized models inside one big model. Instead of using the whole network for every task, Gemini 1.5 activates only the parts (or what they call “experts”) that are most relevant. This means Gemini 1.5 can tackle complex tasks with less processing power than a typical monolithic model.

We can explore Gemini’s features in Google AI Studio since it’s already baked right in. We’ll begin by uploading the following image illustrating VLM capabilities.

We’ll ask Gemini to analyze the image and extract details or concepts:

Explain this image. What are the specific details or concepts it represents?

“The image is a flowchart illustrating different types of image understanding tasks with a Vision Language Model.

• Object Localization: This task aims to identify the precise location of objects within an image. The example question asks, “Is one cat behind another?”
• Zero-shot Segmentation: This task involves segmenting an image into different regions based on a given label, even if the model has never seen that specific label before. The example question asks to segment “striped cat.”
• Zero-shot Visual QA: This task requires answering questions about an image, even if the model has not been specifically trained to answer that type of question. The example question asks, “What is the breed of these cats?”
• One-shot Learning with Instructions: This task involves providing the model with a single example and instruction to learn a new concept and apply it to other images. The example question asks, “Striped cats are called tabby cats. What is the breed of the cats in the image?”

Well, Gemini nailed it — it clearly understood the image and recognized the tasks a VLM handles. This is exactly what you’d expect from a model designed for advanced image analysis.

Now, we’ll upload another image — this time of an Italian dish — and ask Gemini if it can recognize the dishes and list the ingredients needed for them. This type of “food recognition task” will help us test its ability to identify foods and ingredients.

List the different dishes in this image, also from which country, and give me the ingredients I need to make them.

“The image shows an Italian feast with the following dishes:

1. Seafood Stew: A rich and flavorful stew with seafood like clams, mussels, shrimp, fish, and vegetables in a tomato broth.
2. Spaghetti with Tomato Sauce: Classic spaghetti pasta tossed in a simple yet flavorful tomato sauce.
3. Meatballs in Tomato Sauce: Tender and juicy meatballs simmered in a rich tomato sauce.
4. Lasagna: Layered pasta with meat sauce, cheese, and tomato sauce.
5. Side Salad: A refreshing side salad with mixed greens, tomatoes, and other vegetables.
6. Garlic Bread: Toasted bread slices rubbed with garlic and olive oil.
7. Marinara Sauce: A simple tomato-based sauce.

This is a typical Italian meal with various dishes showcasing the flavors of Italian cuisine.

As for the ingredients, you’ll need tomatoes for many of these dishes, specifically for the sauces and the side salad.”

Well, the model did a good job recognizing the dishes, but it also didn’t give me all the necessary ingredients. Let’s see how it does with videos instead, using the same video we used earlier with the Reka models. This time, the task will focus on action recognition.

What is the purpose of this video, and what key actions or processes are being demonstrated?

“The video is a tutorial about the importance of friendship and how it can impact our lives. It demonstrates the use of a video editing software called “Genmy” to create a video and add text subtitles. The video creator is using Genmy to:

• Record their voice: This is seen at the top of the screen with the mic icon.
• Add text to speech: You see the “Text to Speech” option, which is likely being used to generate subtitles or captions for the video.
• Edit the timeline: They’re working with a video timeline, adding and arranging different elements.
• Add voice-over: The speaker is adding commentary to the video.
• Create a visually appealing presentation: They’re using a combination of video footage, text, and voice-over to create an engaging tutorial.”

Well, Gemini gave a clear breakdown of the video, identifying it as a tutorial demonstrating the Genmy video editing software to highlight how it’s used for recording voice, adding text-to-speech, editing video timelines, and allowing voice-over. Impressive!

Let’s upload one more video, the same one we used for Reka about the Parler TTS model, and ask Gemini to analyze and summarize the contents.

Summarize this video and explain how the contents might be relevant or helpful for software engineers.

“This video showcases different voice samples generated by a text-to-speech (TTS) system called “Parler-TTS.” The video highlights various voice characteristics like gender, pace, pitch, and even the simulated environment. For software engineers, this video demonstrates the progress made in TTS technology. These are some insights:

• Voice Variety: The video shows that Parler-TTS can create diverse voices, potentially useful for applications needing different personas or tones.
• Fine-grained Control: The video emphasizes the ability to control voice parameters like pace and pitch, showcasing the potential for customizability.
• Quality and Naturalness: The video focuses on the quality of the generated speech, demonstrating the advancements made in speech synthesis, which is crucial for user experience.”

Nicely done! I can go with that answer. Gemini explains adjusting voice settings, like pitch and speed, and how having different voices can be useful. Gemini also emphasizes the importance of natural, high-quality speech, which is handy for developers working with TTS systems!

Alright, for coding, you can grab the code from Google AI Studio by clicking the Get Code button. You can choose between formatting the code in Python, Swift, and Java, among other languages.

Both Reka and Gemini are strong multimodal models for AI applications, but there are key differences between them to consider. Here’s a table that breaks those down:

Reka stands out for on-device deployment, which is super useful for apps requiring offline capabilities or low-latency processing.

On the other hand, Gemini 1.5 Pro shines with its long context windows, making it a great option for handling large documents or complex queries in the cloud.