Month: August 2024

Hey look at that, the State of CSS Survey for 2024 is open and taking submissions.

Quick Hit #11 originally published on CSS-Tricks, which is part of the DigitalOcean family. You should get the newsletter.

You ever find yourself in bumper-to-bumper traffic? I did this morning on the way to work (read: whatever cafe I fancy). There’s a pattern to it, right? Stop, go, stop, go, stop… it’s almost rhythmic and harmonious in the most annoying of ways. Everyone in line follows the dance, led by some car upfront, each subsequent vehicle pressed right up to the rear of the next for the luxury of moving a few feet further before the next step.

Have you tried breaking the pattern? Instead of playing shadow to the car in front of me this morning, I allowed space between us. I’d gradually raise my right foot off the brake pedal and depress the gas pedal only once my neighboring car gained a little momentum. At that point, my car begins to crawl. And continue crawling. I rarely had to tap the brakes at all once I got going. In effect, I had sacrificed proximity for a smoother ride. I may not be traveling the “fastest” in line, but I was certainly gliding along with a lot less friction.

I find that many things in life are like that. Getting closest to anything comes with a cost, be it financial or consequence. Want the VIP ticket to a concert you’re stoked as heck about? Pony up some extra cash. Want the full story rather than a headline? Just enter your email address. Want up-to-the-second information in your stock ticker? Hand over some account information. Want access to all of today’s televised baseball games? Pick up an ESPN+ subscription.

Proximity and speed are the commodities, the products so to speak. Closer and faster are what’s being sold.

You may have run into the “law of diminishing returns” in some intro-level economics class you took in high school or college. It’s the basis for a large swath of economic theory but in essence, is the “too much of a good thing” principle. It’s what AMPM commercials have been preaching this whole time.

I’m embedding the clip instead of linking it up because it clearly illustrates the “problem” of having too many of what you want (or need). Dude resorted to asking two teens to reach into his front pocket for his wallet because his hands were full, creeper. But buy on, the commercial says, because the implication is that there’s never too much of a good thing, even if it ends in a not-so-great situation chockfull of friction.

The only and only thing I took away from physics in college — besides gravity force being 9.8 m/s² — is that there’s no way to have bigger, cheaper, and faster at the same time. You can take two, but all three cannot play together. For example, you can have a spaceship that’s faster and cheaper, but chances are that it ain’t gonna be bigger than a typical spaceship. If you were to aim for bigger, it’d be a lot less cheap, not only for the extra size but also to make the dang heavy thing go as fast as possible. It’s a good rule in life. I don’t have proof of it, but I’d wager Mick Jagger lives by it, or at least did at one time.

Speed. Proximity. Faster and slower. Closer and further. I’m not going to draw any parallels to web development, UX design, or any other front-end thing. They’re already there.

The Intersection of Speed and Proximity originally published on CSS-Tricks, which is part of the DigitalOcean family. You should get the newsletter.

Almost two years into the AI hype, a looming market correction may soon separate true innovators from those who are trying to capitalize on the hype. The burst of the bubble could pave the way for a more mature phase of AI development.

Amidst recent turmoil on the stock markets, during which the 7 biggest tech companies collectively lost some $650 billion, experts and media alike are warning that the next tech bubble is about to pop (e.g.: The Guardian, Cointelegraph, The Byte). The AI industry has indeed been riding a wave of unprecedented hype and investment, with inflated expectations potentially setting up investors and CEOs for a rude awakening. However, the bursting of a bubble often has a cleansing effect, separating the wheat from the chaff. This article examines the current state of the AI industry, exploring both the signs that point to an imminent burst and the factors that suggest continued growth.

Since the release of ChatGPT started a mainstream hype around AI, it looks like investors jumped at the opportunity to put their money into AI-related projects. Billions have been spent on them this year alone, and analysts expect AI to become a $1 trillion industry within the next 4-5 years. OpenAI alone is currently valued at $80 billion, which is almost twice the valuation of General Motors, or four times that of Western Digital. The list of other AI companies with high valuations has been growing quickly, as has the list of failed AI startups. At the same time, the progress visible to end-users has slowed down, and the hype around AI has been overshadowed by an endless string of PR disasters.

Here are three key reasons why the AI bubble might pop soon:

1. AI doesnt sell. A study led by researchers of Washington State University revealed that using 'artificial intelligence' in product descriptions decreases purchase likelihood. This effect most likely stems from the emotional trust people typically associate with human interaction. AI distrust might have been further fueled by various PR disasters ranging from lying chatbots to discriminatory algorithms and wasteful public spending on insubstantial projects.
2. AI investments aren't paying off. Most AI companies remain unprofitable and lack clear paths to profitability. For instance, OpenAI received a $13 billion investment from Microsoft for a 49% stake. Yet OpenAI's estimated annual revenue from 8.9 million subscribers is just $2.5 billion. Even with minimal operational costs (which isn't the case), Microsoft faces a long road to recouping its investment, let alone profiting.
3. Regulation is hampering progress. End-users have seen little tangible improvement in AI applications over the past year. While video generation has advanced, ChatGPT and other LLMs have become less useful despite boasting higher model numbers and larger training data. A multitude of restrictions aimed, for example, at copyright protection, preventing misuse, and ensuring inoffensiveness have led to a "dumbification of LLMs." This has created a noticeable gap between hype and reality. Nevertheless, AI companies continue hyping minor updates and little new features that fail to meet expectations.

It's also crucial to remember that technology adoption takes time. Despite ChatGPT's record-breaking user growth, it still lags behind Netflix by about 100 million users, and has only about 3.5% of Netflix's paid subscribers. Consider that it took 30 years for half the world's population to get online after the World Wide Web's birth in 1989. Even today, 37% globally (and 9-12% in the US and Europe) don't use the internet. Realistically, AI's full integration into our lives will take considerable time. The burst of economic bubbles is much more likely to occur before that.

A potential counter-argument to the thesis that AI development is slowing down, lacks application value and will struggle to expand its userbase, is that some big players might be hiding groundbreaking developments, which they could pull out of their metaphorical hats any moment. Speculations about much better models or even AGI lurking on OpenAI's internal testing network are nothing new. And indeed it is a fact that tech that is being developed usually surpasses the capabilities of tech that has already been thoroughly tested and released such is the nature of development. While AI development certainly might have the one or the other surprise in stock, and new applications arise all the time, it is questionable if there's a wildcard that can counteract an overheated market and hastily made investments in the billions. So anyone who's invested into AI-related stocks might want to buckle up, as turbulent quarters are likely to be ahead.

Now forget your investment portfolio and think about progress. Here's why a bursting AI bubble might actually benefit the industry:

The thing about bubbles is, they don't say much about the real-life value of a new technology. Sure, the bursting of a bubble might show that a useless thing is useless, as was the case with NFTs, which got hyped up and then quickly lost their "value" (NFTs really were the tulip mania of the digital age). But the bursting of bubbles also does not render a useful thing useless. There are many good examples for this:

• During the .com-bubble of the late 1990s countless companies boasting little more than a registered domain name were drastically overvalued and when the bubble did burst their stock became worthless from one day to another. Yet, .com-services are not only still around, they have become the driving force behind the economy.
• The bursting of the crypto bubble in early 2018 blasted many shitcoins into oblivion, but Bitcoin is still standing and not far off its all-time high. Also, blockchain tech is already applied in many areas other than finance e.g. in supply-chain management.
• The crash of the housing market in 2007 worked a little differently, as it was not a tech-bubble. Property was hopelessly overvalued and people couldn't keep up with rising interest rates. The bursting of the bubble exposed a dire reality of financial markets where investors bet on whether you will be able to pay your mortgage or not. And today? Well, take a look at the chart on average, housing in the US costs almost twice as much now as it did at the height of the bubble of 2007. Even when adjusted for inflation, buying a house is now more expensive than ever before.

In case of the housing market, the bursting of the bubble had the effect that mortgages became more difficult to access and financial speculations became a little more regulated. In the case of the .com- and crypto-bubble, however, the burst had a cleansing effect that drove away the fakes and shillers, and left the fraction of projects alive that were actually on to something. It can be suspected that a bursting of the AI bubble would have a similar effect.

While the prospect of an AI bubble burst may cause short-term market turbulence, it could ultimately prove beneficial for the industry's long-term health and innovation. A market correction would likely weed out ventures that lack substance and redirect focus towards applications with real-world impact.

Investors, developers, and users alike should view this potential reset not as an end, but as a new beginning. The AI revolution is far from over it's entering a more mature, pragmatic phase.

In a previous article, I compared GPT-4o mini vs. GPT-4o and GPT-3.5 Turbo for zero-shot text summarization. The results showed that the GPT-4o mini achieves almost similar performance for zero-shot text classification at a much-reduced price compared to the other models.

I will compare Meta Llama 3.1 70b with OpenAI GPT-4o snapshot for zero-shot text summarization in this article. Meta Llama 3.1 series consists of Meta's state-of-the-art LLMs, including Llama 3.1 8b, Llama 3.1 70b, and Llama 3.1 405b. On the other hand, [OpenAI GPT-4o[(https://platform.openai.com/docs/models)] snapshot is OpenAIs latest LLM. We will use the Groq API to access Meta Llama 3.1 70b and the OpenAI API to access GPT-4o snapshot model.

So, let's begin without ado.

The following script installs the Python libraries you will need to run scripts in this article.

!pip install openai
!pip install groq
!pip install rouge-score
!pip install --upgrade openpyxl
!pip install pandas openpyxl

The script below installs the required libraries into your Python application.

import os
import time
import pandas as pd
from rouge_score import rouge_scorer
from openai import OpenAI
from groq import Groq

This article will summarize the text in the News Articles with Summary dataset. The dataset consists of article content and human-generated summaries.

The following script imports the CSV dataset file into a 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)
dataset['summary_length'] = dataset['human_summary'].apply(len)
average_length = dataset['summary_length'].mean()
print(f"Average length of summaries: {average_length:.2f} characters")
print(dataset.shape)
dataset.head()

Output:

The content column stores the article's text, and the human_summary column contains the corresponding human-generated summaries.

We also calculate the average number of characters in the human-generated summaries, which we will use to generate summaries via the LLM models.

We are now ready to summarize articles using GPT-4o snapshot and Llama 3.1 70b.

First, we'll create an instance of the OpenAI class, which we'll use to interact with various OpenAI language models. When initializing this object, you must provide your OpenAI API Key.

Additionally, we'll define the calculate_rouge() function, which computes the ROUGE-1, ROUGE-2, and ROUGE-L scores by comparing the LLM-generated summaries with the human-generated ones.

ROUGE scores are used to evaluate the quality of machine-generated text, such as summaries, by comparing them with human-generated text. ROUGE-1 evaluates the overlap of unigrams (single words), ROUGE-2 considers bigrams (pairs of consecutive words), and ROUGE-L focuses on the longest common subsequence between the two texts.

client = OpenAI(
    # This is the default and can be omitted
    api_key = os.environ.get('OPENAI_API_KEY'),
)

# 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()}

Next, we will iterate through the first 20 articles in the dataset and call the GPT-4o snapshot model to produce a summary of the article with a target length of 1150 characters. We will use 1150 characters because the average length of the human-generated summaries is 1168 characters. Next, the LLM-generated and human-generated summaries are passed to the calculate_rouge() function, which returns ROUGE scores for the LLM-generated summaries. These ROUGE scores, along with the generated summaries, are stored in the results list.

%%time

results = []

i = 0

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

    i = i + 1
    print(f"Summarizing article {i}.")

    prompt = f"Summarize the following article in 1150 characters. The summary should look like human created:\n\n{article}\n\nSummary:"

    response = client.chat.completions.create(
        model= "gpt-4o-2024-08-06",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=1150,
        temperature=0.7
    )
    generated_summary = response.choices[0].message.content
    rouge_scores = calculate_rouge(human_summary, generated_summary)

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

Output:

The above output shows that it took 59 seconds to summarize 20 articles.

Next, we convert the results list into a results_df dataframe and display the average ROUGE scores for 20 articles.

results_df = pd.DataFrame(results)
mean_values = results_df[["rouge1", "rouge2", "rougeL"]].mean()
print(mean_values)

Output:

rouge1    0.386724
rouge2    0.100371
rougeL    0.187491
dtype: float64

The above results show that ROUGE scores obtained by GPT-4o snapshot are slightly less than the results obtained by GPT-4o model in the previous article.

Let's evaluate the summarization of GPT-4o using another LLM, GPT-4o mini, in this case.

In the following script, we define the llm_evaluate_summary() function, which accepts the original article and LLM-generated summary and evaluates it on the completeness, conciseness, and coherence criteria.

def llm_evaluate_summary(article, summary):
    prompt = f"""Evaluate the following summary for the given article. Rate it on a scale of 1-10 for:
    1. Completeness: Does it capture all key points?
    2. Conciseness: Is it brief and to the point?
    3. Coherence: Is it well-structured and easy to understand?

    Article: {article}

    Summary: {summary}

    Provide the ratings as a comma-separated list (completeness,conciseness,coherence).
    """
    response = client.chat.completions.create(
        model= "gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=100,
        temperature=0.7
    )
    return [float(score) for score in response.choices[0].message.content.strip().split(',')]

We iterate through the first 20 articles and pass the content and LLM-generated summaries to the llm_evaluate_summary() function.

scores_dict = {'completeness': [], 'conciseness': [], 'coherence': []}

i = 0
for _, row in results_df.iterrows():
    i = i + 1
    # Corrected method to access content by article_id
    article = dataset.loc[dataset['id'] == row['article_id'], 'content'].iloc[0]
    scores = llm_evaluate_summary(article, row['generated_summary'])
    print(f"Article ID: {row['article_id']}, Scores: {scores}")

    # Store the scores in the dictionary
    scores_dict['completeness'].append(scores[0])
    scores_dict['conciseness'].append(scores[1])
    scores_dict['coherence'].append(scores[2])

Finally, the script below calculates and displays the average scores for completeness, conciseness, and coherence for GPT-4o snapshot summaries.

# Calculate the average scores
average_scores = {
    'completeness': sum(scores_dict['completeness']) / len(scores_dict['completeness']),
    'conciseness': sum(scores_dict['conciseness']) / len(scores_dict['conciseness']),
    'coherence': sum(scores_dict['coherence']) / len(scores_dict['coherence']),
}

# Convert to DataFrame for better visualization (optional)
average_scores_df = pd.DataFrame([average_scores])
average_scores_df.columns = ['Completeness', 'Conciseness', 'Coherence']

# Display the DataFrame
average_scores_df.head()

Output:

In this section, we will perform a zero-shot text summarization of the same set of articles using the Llama 3.1 70b model.

You should try the Llama 3.1 405b model to get better results. However, at the time of writing this article, Groq Cloud had suspended the API calls for Llama 405b due to excessive demand. You can also try other cloud providers to run Llama 3.1 405b.

The process remains the same for text summarization using Meta Llama 3.1 70b. The only difference is that we will create an object of the Groq client in this case.

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

Next, we will iterate through the first 20 articles in the dataset, generate their summaries using the Llama 3.1 70b model, calculate ROUGE scores, and store the results in the results list.

%%time

results = []

i = 0

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

    i = i + 1
    print(f"Summarizing article {i}.")

    prompt = f"Summarize the following article in 1150 characters. The summary should look like human created:\n\n{article}\n\nSummary:"

    response = client.chat.completions.create(
          model="llama-3.1-70b-versatile",
          temperature = 0.7,
          max_tokens = 1150,
          messages=[
                {"role": "user", "content":  prompt}
            ]
    )

    generated_summary = response.choices[0].message.content
    rouge_scores = calculate_rouge(human_summary, generated_summary)

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

Output:

The above output shows that it only took 24 seconds to process 20 article using Llama 3.1 70b. The faster processing is because Llama 3.1 70b is a smaller model than the GPT-4o snapshot. Also, Groq uses LPU (language processing unit) which is much faster for LLM inference.

Next, we will convert the results list into the results_df dataframe and display the average ROUGE scores.

results_df = pd.DataFrame(results)
mean_values = results_df[["rouge1", "rouge2", "rougeL"]].mean()
print(mean_values)

Output:

rouge1    0.335863
rouge2    0.080865
rougeL    0.170834
dtype: float64

The above output shows that the ROUGE scores for Meta Llama 3.1 70b are lower compared to the GPT-40 snapshot model. I would again stress that you should use Llama 3.1 405b to get better results.

Finally, we will evaluate the summaries generated via Llama 3.1 70b using the GPT-4o mini model for completeness, conciseness, and coherence.

client = OpenAI(
    # This is the default and can be omitted
    api_key = os.environ.get('OPENAI_API_KEY'),
)

scores_dict = {'completeness': [], 'conciseness': [], 'coherence': []}

i = 0
for _, row in results_df.iterrows():
    i = i + 1
    # Corrected method to access content by article_id
    article = dataset.loc[dataset['id'] == row['article_id'], 'content'].iloc[0]
    scores = llm_evaluate_summary(article, row['generated_summary'])
    print(f"Article ID: {row['article_id']}, Scores: {scores}")

    # Store the scores in the dictionary
    scores_dict['completeness'].append(scores[0])
    scores_dict['conciseness'].append(scores[1])
    scores_dict['coherence'].append(scores[2])

# Calculate the average scores
average_scores = {
    'completeness': sum(scores_dict['completeness']) / len(scores_dict['completeness']),
    'conciseness': sum(scores_dict['conciseness']) / len(scores_dict['conciseness']),
    'coherence': sum(scores_dict['coherence']) / len(scores_dict['coherence']),
}

# Convert to DataFrame for better visualization (optional)
average_scores_df = pd.DataFrame([average_scores])
average_scores_df.columns = ['Completeness', 'Conciseness', 'Coherence']

# Display the DataFrame
average_scores_df.head()

Output:

The above output shows that Llama 3.1 70b achieves performance similar to GPT-4o snapshot for text summarization when evaluated using 3rd LLM.

Meta Llama 3.1 series models are state-of-the-art open-source models. This article shows that Meta Llama 3.1 70b performs very similarly to GPT-4o snapshot for zero-shot text summarization. I stress that you use the Llama 3.1 405b model from Groq to see if you can get better results than GPT-4o.

Pricing projects can be one of the most challenging aspects of running a digital agency or working as a freelance web designer. It’s a topic that comes up frequently in discussions with fellow professionals in my Agency Academy.

Over my years in the industry, I’ve found that there are essentially three main approaches to pricing:

• Fixed price,
• Time and materials,
• And value-based pricing.

Each has its merits and drawbacks, and understanding these can help you make better decisions for your business. Let’s explore each of these in detail and then dive into what I believe is the most effective strategy.

Fixed pricing is often favored by clients because it reduces their risk and allows for easier comparison between competing proposals. On the surface, it seems straightforward: you quote a price, the client agrees, and you deliver the project for that amount. However, this approach comes with significant drawbacks for agencies and freelancers:

• Estimating accurately is incredibly challenging.
  In the early stages of a project, we often don’t have enough information to provide a precise quote. Clients may not have a clear idea of their requirements, or there might be technical complexities that only become apparent once work begins. This lack of clarity can lead to underquoting, which eats into your profits, or overquoting, which might cost you the job.
• There’s no room for adaptation based on testing or insights gained during the project.
  Web design and development is an iterative process. As we build and test, we often discover better ways to implement features or uncover user needs that weren’t initially apparent. With a fixed price model, these improvements are often seen as “scope creep” and can lead to difficult conversations with clients about additional costs.
• The focus shifts from delivering the best possible product to sticking within the agreed-upon scope.
  This can result in missed opportunities for innovation and improvement, ultimately leading to a less satisfactory end product for the client.

While fixed pricing might seem straightforward, it’s not without its complications. The rigidity of this model can stifle creativity and adaptability, two crucial elements in successful web projects. So, let’s look at an alternative approach that offers more flexibility.

Time and materials (T&M) pricing offers a fairer system where the client only pays for the hours actually worked. This approach has several advantages:

• Allows for greater adaptability as the project progresses. If new requirements emerge or if certain tasks take longer than expected, you can simply bill for the additional time. This flexibility can lead to better outcomes as you’re not constrained by an initial estimate.
• Encourages transparency and open communication. Clients can see exactly what they’re paying for, which can foster trust and understanding of the work involved.
• Reduces the risk of underquoting. You don’t have to worry about eating into your profits if a task takes longer than expected.

However, T&M pricing isn’t without its drawbacks:

• It carries a higher perceived risk for the client, as the final cost isn’t determined upfront. This can make budgeting difficult for clients and may cause anxiety about runaway costs.
• It requires careful tracking and regular communication about hours spent. Without this, clients may be surprised by the final bill, leading to disputes.
• Some clients may feel it incentivizes inefficiency, as taking longer on tasks results in higher bills.

T&M pricing can work well in many scenarios, especially for long-term or complex projects where requirements may evolve. However, it’s not always the perfect solution, particularly for clients with strict budgets or those who prefer more certainty. There’s one more pricing model that’s often discussed in the industry, which attempts to tie pricing directly to results.

Value-based pricing is often touted as the holy grail of pricing strategies. The idea is to base your price on the value your work will generate for the client rather than on the time it takes or a fixed estimate. While this sounds great in theory, it’s rarely a realistic approach in our industry. Here’s why:

• It’s only suitable for projects where you can tie your efforts directly to ROI (Return on Investment). For example, if you’re redesigning an e-commerce site, you might be able to link your work to increased sales. However, for many web projects, the value is more intangible or indirect.
• Accurately calculating ROI is often difficult or impossible in web design and development. Many factors contribute to a website’s success, and isolating the impact of design or development work can be challenging.
• It requires a deep understanding of the client’s business and industry. Without this, it’s hard to accurately assess the potential value of your work.
• Clients may be reluctant to share the financial information necessary to make value-based pricing work. They might see it as sensitive data or simply may not have accurate projections.
• It can lead to difficult conversations if the projected value isn’t realized. Was it due to your work or other factors beyond your control?

While these three approaches form the foundation of most pricing strategies, the reality of pricing projects is often more nuanced and complex. In fact, as I point out in my article “How To Work Out What To Charge Clients: The Honest Version”, pricing often involves a mix of educated guesswork, personal interest in the project, and an assessment of what the market will bear.

Given the challenges with each of these pricing models, you might be wondering if there’s a better way. In fact, there is, and it starts with a different approach to the initial client conversation.

Instead of jumping straight into deliverables or hourly rates, I’ve found it more effective to start by discussing what 37signals calls “appetite” in their book Shaping Up. Appetite is how much the product owner is willing to invest based on the expected return for their business. This concept shifts the conversation from “What will this cost?” to “What is this worth to you?”

This approach is beneficial for several reasons:

• Focuses on the budget rather than trying to nail down every deliverable upfront. This allows for more flexibility in how that budget is allocated as the project progresses.
• Allows you to tailor your proposal to what the client can actually afford. There’s no point in proposing a $100,000 solution if the client only has $20,000 to spend.
• Helps set realistic expectations from the start. If a client’s appetite doesn’t align with what’s required to meet their goals, you can have that conversation early before investing time in detailed proposals.
• Shifts the conversation from price comparison to value delivery. Instead of competing solely on price, you’re discussing how to maximize the value of the client’s investment.
• Mirrors how real estate agents work — they ask for your budget to determine what kind of properties to show you. This analogy can help clients understand why discussing budgets early is crucial.

To introduce this concept to clients, I often use the real estate analogy. I explain that even if you describe your ideal house (e.g., 3 bedrooms, specific location), a real estate agent still cannot give you a price because it depends on many other factors, including the state of repair and nearby facilities that may impact value. Similarly, in web design and development, many factors beyond the basic requirements affect the final cost and value of a project.

Once you’ve established the client’s appetite, you’re in a much better position to structure your pricing. But how exactly should you do that? Let me share a strategy that’s worked well for me and many others in my Agency Academy.

Here’s an approach I’ve found highly effective:

1. Take approximately 10% of the total budget for a discovery phase. This can be a separate contract with a fixed price. During this phase, you dig deep into the client’s needs, goals, and constraints. You might conduct user research, analyze competitors, and start mapping out the project’s architecture.
2. Use the discovery phase to define what needs to be prototyped, allowing you to produce a fixed price for the prototyping sub-project. This phase might involve creating wireframes, mockups, or even a basic working prototype of key features.
3. Test and evolve the prototype, using it as a functional specification for the build. This detailed specification allows you to quote the build accurately. By this point, you have a much clearer picture of what needs to be built, reducing the risk of unexpected complications.

This approach combines elements of fixed pricing (for each sub-project) with the flexibility to adapt between phases. It allows you to provide more accurate estimates while still maintaining the ability to pivot based on what you learn along the way.

This method offers several key benefits:

• Clients appreciate the sense of control over the budget. They can decide after each phase whether to continue, giving them clear exit points if needed.
• It reduces the perceived risk for clients, as they could theoretically change suppliers between sub-projects. This makes you a less risky option compared to agencies asking for a commitment to the entire project upfront.
• Each sub-project is easier to price accurately. As you progress, you gain more information, allowing for increasingly precise estimates.
• It allows for adaptability between sub-projects, eliminating the problem of scope creep. If new requirements emerge during one phase, they can be incorporated into the planning and pricing of the next phase.
• It encourages ongoing communication and collaboration with the client. Regular check-ins and approvals are built into the process.
• It aligns with agile methodologies, allowing for iterative development and continuous improvement.

This sub-project approach not only helps with more accurate pricing but also addresses one of the most common challenges in project management: scope creep. By breaking the project into phases, you create natural points for reassessment and adjustment. For a more detailed look at how this approach can help manage scope creep, check out my article “How To Price Projects And Manage Scope Creep.”

This approach sounds great in theory, but you might be wondering how clients typically react to it. Let’s address some common objections and how to handle them.

You may encounter resistance to this approach, especially in formal bid processes where clients are used to receiving comprehensive fixed-price quotes. Here’s how to handle common objections:

“We need a fixed price for the entire project.”

Provide an overall estimate based on their initial scope, but emphasize that this is a rough figure. Use your sub-project process as a selling point, explaining how it actually provides more accurate pricing and better results. Highlight how inaccurate other agency quotes are likely to be and warn about potential scope discussions later.

“This seems more complicated than other proposals we've received.”

Acknowledge that it may seem more complex initially, but explain how this approach actually simplifies the process in the long run. Emphasize that it reduces risk and increases the likelihood of a successful outcome.

“We don't have time for all these phases.”

Explain that while it may seem like more steps, this approach often leads to faster overall delivery because it reduces rework and ensures everyone is aligned at each stage.

“How do we compare your proposal to others if you’re not giving us a fixed price?”

Emphasize that the quality and implementation of what agencies quote for can vary wildly. Your approach ensures they get exactly what they need, not just what they think they want at the outset. Encourage them to consider the long-term value and reduced risk, not just the initial price tag.

“We’re not comfortable discussing our budget upfront.”

Use the real estate analogy to explain why discussing the budget upfront is crucial. Just as a real estate agent needs to know your budget to show you appropriate properties, you need to understand their investment appetite to propose suitable solutions.

By adopting this approach to pricing, you can create a more collaborative relationship with your clients, reduce the risk for both parties, and ultimately deliver better results.

Remember,

Pricing isn’t just about numbers — it’s about setting the foundation for a successful project and a positive client relationship.

By being transparent about your process and focusing on delivering value within the client’s budget, you’ll set yourself apart in a crowded market.

In my previous articles, I presented a comparison of OpenAI GPT-4o mini model with GPT-4o and GPT-3.5 turbo models for zero-shot text classification. The results showed that GPT-4o mini, while significantly cheaper than its counterparts, achieves comparable performance.

On 8 August 2024, OpenAI enabled GPT-4o mini fine-tuning for developers across usage tiers 1-5. You can now fine-tune GPT-4o mini for free until 23 September 2024, with a daily token limit of 2 million.

In this article, I will show you how to fine-tune the GPT-4o mini for text classification tasks and compare it to the fine-tuned GPT-3.5 turbo.

So, let's begin without ado.

The following script installs the OpenAI Python library you can use to make calls to the OpenAI API.

!pip install openai

The script below imports the required liberaries into your Python application.

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from openai import OpenAI
import pandas as pd
import os
import json

We will use the Twitter US Airline Sentiment dataset for fine-tuning the GPT-4o mini and GPT-3.5 turbo models.

The following script imports the dataset and defines the preprocess_data() function. This function takes in a dataset and an index value as inputs. It then divides the dataset by sentiment category, returning 34, 33, and 33 tweets from each category, beginning at the specified index. This approach ensures we have around 100 balanced records. You can use more number of records for fine-tuning if you want.

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

def preprocess_data(dataset, n):

    # 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']

    # Select records from Nth index
    neutral_sample = neutral_df[n: n +34]
    positive_sample = positive_df[n: n +33]
    negative_sample = negative_df[n: 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)

    dataset = dataset[["text", "airline_sentiment"]]

    return dataset

The following script creates a balanced training dataset.

training_data = preprocess_data(dataset, 0)
print(training_data["airline_sentiment"].value_counts())
training_data.head()

Output:

Similarly, the script below creates a test dataset.

test_data = preprocess_data(dataset, 100)
print(test_data["airline_sentiment"].value_counts())
test_data.head()

Output:

To fine-tune an OpenAI model, you need to transform the training data into JSON format, as outlined in the OpenAI official documentation. To achieve this, I have written a straightforward function that converts the input Pandas DataFrame into the required JSON structure.

The following script converts the training data into OpenAI complaint JSON format for fine-tuning. Fine-tuning relies significantly on the content specified for the system role, so pay special attention when setting this value.

# JSON file path
json_file_path = r"D:\Datasets\airline_sentiments.json"

# Function to create the JSON structure for each row
def create_json_structure(row):
    return {
        "messages": [
            {"role": "system", "content": "You are a Twitter sentiment analysis expert who can predict sentiment expressed in the tweets about an airline. You select sentiment value from positive, negative, or neutral."},
            {"role": "user", "content": row['text']},
            {"role": "assistant", "content": row['airline_sentiment']}
        ]
    }

# Convert DataFrame to JSON structures
json_structures = training_data.apply(create_json_structure, axis=1).tolist()

# Write JSON structures to file, each on a new line
with open(json_file_path, 'w') as f:
    for json_structure in json_structures:
        f.write(json.dumps(json_structure) + '\n')

print(f"Data has been written to {json_file_path}")

Output:

Data has been written to D:\Datasets\airline_sentiments.json

The next step is to upload your JSON file to the OpenAI server. To do so, start by creating an OpenAI client object. Then, call the files.create() method, passing the file path as an argument, as demonstrated in the following script:

client = OpenAI(
    # This is the default and can be omitted
    api_key = os.environ.get('OPENAI_API_KEY'),
)


training_file = client.files.create(
  file=open(json_file_path, "rb"),
  purpose="fine-tune"
)

print(training_file.id)

Once the file is uploaded, you will receive a file ID, as the above script demonstrates. You will use this file ID to fine-tune your OpenAI model.

To start fine-tuning, you must call the fine_tuning.jobs.create() method and pass it the ID of the uploaded training file and the model name. The current model name for GPT-4o mini is gpt-4o-mini-2024-07-18.

fine_tuning_job_gpt4o_mini = client.fine_tuning.jobs.create(
  training_file=training_file.id,
  model="gpt-4o-mini-2024-07-18"
)

Executing the above script initiates the fine-tuning process. The following script allows you to monitor and display various fine-tuning events.

# List up to 10 events from a fine-tuning job
print(client.fine_tuning.jobs.list_events(fine_tuning_job_id = fine_tuning_job_gpt4o_mini.id,
                                    limit=10))

Once fine-tuning is complete, you will receive an email containing the ID of your fine-tuned model, which you can use to make inferences. Alternatively, you can retrieve the ID of your fine-tuned model by running the following script.

ft_model_id = client.fine_tuning.jobs.retrieve(fine_tuning_job_gpt4o_mini.id).fine_tuned_model

The remainder of the process follows the same steps as outlined in a previous article. We will define the find_sentiment() function and pass it our fine-tuned model and the test set to predict the sentiment of the tweets in the dataset.

Finally, we predict the model's accuracy by comparing the actual and predicted sentiments of the tweets.

def find_sentiment(client, model, dataset):
    tweets_list = dataset["text"].tolist()

    all_sentiments = []


    i = 0


    while i < len(tweets_list):

        try:
            tweet = tweets_list[i]
            content = """What is the sentiment expressed in the following tweet about an airline?
            Select sentiment value from positive, negative, or neutral. Return only the sentiment value in small letters.
            tweet: {}""".format(tweet)

            response = client.chat.completions.create(
                model=model,
                temperature=0,
                max_tokens=10,
                messages=[
                    {"role": "user", "content": content}
                ]
            )

            sentiment_value = response.choices[0].message.content

            all_sentiments.append(sentiment_value)
            i += 1
            print(i, sentiment_value)

        except Exception as e:
            print("===================")
            print("Exception occurred:", e)

    accuracy = accuracy_score(all_sentiments, dataset["airline_sentiment"])
    print(f"Accuracy: {accuracy}")

find_sentiment(client,ft_model_id, test_data)

Output:

Accuracy: 0.78

The above output shows that the fine-tuned GPT-4o mini achieves a performance accuracy of 78% on the test set.

For comparison, we will also fine-tune the GPT-3.5 turbo model for text classification.

The fine-tuning process remains the same as for the GPT-4o mini. We will pass the training file ID and the GPT-3.5 turbo model ID to the client.fine_tuning.jobs.create() method, as shown below.

fine_tuning_job_gpt_3_5 = client.fine_tuning.jobs.create(
  training_file=training_file.id,
  model="gpt-3.5-turbo"
)

Next, we will pass the fine-tuned GPT-3.5 model ID and the test dataset to the find_sentiment() function to evaluate the model's performance on the test set.

ft_model_id = client.fine_tuning.jobs.retrieve(fine_tuning_job_gpt_3_5.id).fine_tuned_model
find_sentiment(client,ft_model_id, test_data)

Output:

Accuracy: 0.82

The above output shows that the GPT-3.5 turbo model achieves 82% performance accuracy, 4% higher than the GPT-4o mini model.

GPT-4o mini is a cheaper and faster alternative to GPT-3.5. My last article showed that it achieves higher performance for zero-shot text classification than the GPT-3.5 turbo model.

However, based on the results presented in this article, a fine-tuned GPT-3.5 turbo model is still better than a fine-tuned GPT-4o mini.

Feel free to share your feedback in the comments section.

Hey guys! I started a keylogger project two months back, and I've hit a slump relating to what features I can add to make it more complex and less basic.
So I just wanted to hear any suggestions anyone might have, so I find some inspiration.
Note: This project is for research purposes only and will not be used in an unethical manner.

Which ports and connectivity options are necessary when looking to buy a laptop?

Blogging has emerged as a dynamic and impactful channel for writers to express their ideas. They share their expertise and foster community as well. Strategic planning is very important if you want to stand out as a writer and generate revenue. It is especially crucial for creators and bloggers who aspire to turn their passion into a profitable venture.

Today, there are new trends in blog monetization that you must not overlook. This article is your ultimate guide to the current state of blog monetization in 2024. Not only will it provide you with valuable insights and strategies, but it will also help you unlock the full potential of the platforms you use. So, whether you’re an established content creator or an aspiring blogger looking to diversify your revenue streams, this article is a must-read.

Relevance of Blogging in 2024

Many people wonder if blogging is still relevant today, and the answer is yes! In fact, blogging is more important than ever. It provides a powerful medium for sharing information, connecting with audiences, promoting brands, and establishing authority in your niche. While video and social media marketing has become more popular, blogging still remains a fundamental and essential component of the online landscape. There are countless reasons why blogging is still relevant, including;

In-depth content and valuable insights

Blogging lets writers and content creators delve deep into various topics and provide valuable insights. Unlike creating content on social media, which is quite limited, blogs offer flexibility to explain complex concepts. Moreover, there is ample space for gaining an in-depth understanding of any subject matter.

Search Engine Optimization (SEO)

Blogs play a significant role in generating traffic to websites. They are a crucial part of every website as they will help it rank better. SEO favors websites with high-quality, relevant, and fresh content.

This feature is quite noticeable with e-commerce websites creating separate blog content pages.

Long-Term Value

Unlike some social media posts, blog posts have a longer shelf life. A well-written blog post can continue generating traffic and revenue long after publication.

Diverse content type

Blogs can incorporate diverse content types, including text, videos, images, infographics, and interactive elements. This versatility enables content creators to cater to different learning styles and broaden their audience reach.

Branding and marketing

It is known that a blog is an effective brand marketing strategy. It complements branding and provides a platform to communicate the brand’s values and mission. Blogs can as well be used to promote products and services.

Community building

Blogs provide a platform for building community relationships. Bloggers can create a safe space for readers to share their thoughts and opinions on the content through comments and discussion sessions.

Blog Content Strategies

Running a successful blog will require a carefully thought-out strategy aligning with your blog’s objectives. You should also consider the interest of your target audience and ensure that your blog content keeps them engaged. Here are some helpful strategies to consider;

Define your target audience

Before creating your content, you need to identify who this content is directed to. Who is your target audience? What do you aim to achieve? Identify their needs, preferences, and point points. After this, you can tailor your content to meet their needs and provide value.

Plan your content

One of the main challenges most bloggers face is consistency. You should always plan your content. Draft out a content calendar to help you plan better. Planning will help you maintain consistency and help you cover a wide variety of topics relevant to your audience. You should also include important dates and holidays in your calendar to help you capitalize on timely content.

Conduct in-depth keyword research

One effective way to optimize your blog for search engines is keyword research. Identify relevant keywords (ensure they align with your content) and incorporate them naturally in your blog post.

Offer valuable content

This strategy is the most important as no one will want to engage with boring or meaningless content. You should always focus on creating quality, unique, and valuable content. One tip is to provide information and insights that solve your audience’s problems. Everybody is on the lookout for solutions to their problems.

Incorporate visual elements

Include visual elements such as images, videos, and infographics to enhance the user experience. Visual elements help break long text forms and make your content more appealing.

Encourage reader engagement

Always encourage your audience interaction by inviting comments and discussions at the end of each post. Respond briefly to comments and questions, as this will foster a sense of community with your audience.

Monitor analytics

Keep a close eye on your analytics. This strategy will give you a clear understanding of which content resonates with your audience more. Analyze your page views, social shares, and bounce rates to refine your content strategically.

Blog Monetization Strategies In 2024

So far, this article has given you the importance of blogging and the strategies to run a successful blog. The next thing to tackle is blog monetization. In lay terms, blog monetization means generating revenue from a blog. By monetization, you aim to turn your blog into a source of income by utilizing various revenue streams.

The landscape of blog monetization is evolving rapidly. While some strategies have remained the same, some new methods have emerged. Some common blog monetization strategies include;

Affiliate and Referral Marketing

Affiliate marketing in 2024 remains the most effective way bloggers monetize their blogs. But how does it work? Usually, you receive a unique coupon code to share with your audience. When a reader clicks on the link and purchases the service, you receive a commission based on the reader’s activity on the platform. This strategy is an excellent form of marketing as you generate conversions and revenue.

This is also an attractive opportunity for bloggers in various niches as it appeals to a broad spectrum of readers. Another opportunity comes from referral marketing. This is when users refer the service or product to their contacts using the referral code. In the end, the referrer gets a bonus. Some services have referral programs where you can earn passive income and generate yourself yet another revenue stream.

It is recommended to incentivize your audience by crafting comprehensive reviews and tutorials that showcase mutual benefits, earnings potential, and positive impact. Sharing personal success stories about your experience with your affiliates can help build trust and encourage referrals, ultimately leading to tremendous success for all parties involved.

Advertising

Advertising is one of the most commonly used strategies for blog monetization. This process involves displaying ads on your blog and earning revenue based on various metrics. These metrics include; clicks, impressions, and conversions.

Unlike other monetization strategies, you don’t need to worry about creating or managing products. Your primary focus should be creating valuable content that aligns with the ads.

Display Ads

This type of advertising is a text-based or graphical ad that appears on your blog. Some standard display ads network includes; Google AdSense, Apple advertising, and Facebook audience network ads. These networks use conceptual strategies to display relevant ads based on your blog content.

Sponsored Content

Sponsored posts are another common type of advertisement. Sponsored ads, articles, and blog content are created based on brand collaboration. This content is usually promotional, but you should ensure that it still provides value to your audience. One main pro of sponsored posts is that you don’t have to deal with order fulfillment and customer support. The brands you are in collaboration with handle all the backend operations.

Digital Products

Digital products offer a profitable blog monetization strategy that allows bloggers to leverage their skills and creativity to generate revenue. These products are primarily downloadable materials and resources that provide value to your audience. Here are some popular types of digital products;

• Online courses : You can create in-depth educational practices that can be delivered through audio, video, and written content. Your lessons could also have live elements like webinars.
• Ebooks : You can also create written guides on topics relevant to your niche. Ensure that the book offers a problem-solving approach to your audience’s issues.
• Software and apps : Another lucrative digital product is creating software tools and mobile apps that cater to your audience’s needs. Creative software tools are highly profitable as you promote your expertise while building a helpful option for your audience.
• Templates and worksheets : You can create ready-to-use templates, worksheets, and checklists to help your audience with practical organizations and tasks.

Side hustles

Side hustles can complement your blog monetization strategies and provide an additional income stream. A side hustle will serve as a secondary source of income pursued alongside your main hustle, in this case, blogging. By diversifying your income stream, you set yourself up for success and financial stability. Here are good options for a side hustle;

Freelance Services

While blogging, you may have developed valuable skills such as graphic design, writing, video editing, social media management, and website development. You can monetize these skills by offering these services as a freelancer. You can promote your extra services on your blog or various freelance platforms and connect with clients who need assistance in relevant areas of your expertise.

However, freelancing doesn’t always require skills. There are multiple platforms that will offer you money in exchange for you to complete some small tasks, like filling in surveys.

Print-on demand merchandise

You can design print-on-demand merchandise and sell it to your dedicated audience. You can create branded mugs, t-shirts, pens, and stickers without holding inventory. This side hustle is a great way to promote your blog and services while earning extra income.

Coaching and consultation

You can offer coaching or consulting services if you have successfully built authority in your niche. Whether it’s personal development, fitness, finance or business coaching, or any specialized area offering one-on-one consulting services is a high-end monetization strategy.

Membership/Subscription

The membership/subscription is a blog monetization strategy where you offer premium and exclusive content, services, or products in exchange for a recurring fee. Your subscribers will gain access to premium benefits that regular readers don’t have access to. This method effectively generates extra revenue while maintaining a sense of community and loyalty among your audience. Here are tips to successfully utilize this strategy;

• Offer exclusive content and value : One core element for a successful membership/subscription model is to offer exclusive content. This content may be in the form of long-form articles, premium videos, guides, tutorials, templates, or any other resources that can cater to your audience’s needs.
• Offer tiered offers and pricing : Another essential element is to offer tiered pricing with varying levels of benefits. This offer allows readers to choose a subscription that suits their budget and needs. Additionally, you can include discounts, early access sign-ups, and special offers for your subscriptions.
• Offer free trial and sampling : By offering free trial and samples, you can attract potential subscribers by showcasing the value they will receive if they subscribe. Free trials will also give readers a taste of what to expect and encourage them to switch to paid subscriptions.

Impact Of Emerging Technologies On Blog Monetization

Emerging Technologies have a significant impact on blog monetization, presenting both opportunities and challenges for you. As new technologies evolve, user behaviors change, and tools change as well. You must adopt an effective strategy to stay successful in the ever-changing online landscape. Here are vital aspects of where emerging technologies affect blog monetization and tips on staying successful irrespective of the change.

Content Formats

Video content, virtual reality, and streaming are gaining massive popularity. You will need to change your content format to meet the needs of your audience preference.

Mobile Optimization

With the increasing use of mobile phones, you must ensure your website is optimized for mobile viewing. Consider mobile-friendly designs, responsive layouts, and fast-loading pages to ensure a seamless user experience for your audience.

Social Media Marketing

As social media continues to evolve, it provides new opportunities for you to reach a wider audience. Build a solid social media presence and regularly engage with your audience.

Voice Search and SEO

Over the years, voice search has become more prevalent with the rise of virtual assistants like Alexa and Siri. You will need to optimize your content for voice search queries.

Blockchain

Blockchain technology enables micropayments. You will need to explore blockchain-based platforms to monetize your content through micropayments. Blockchain technology will help your readers to be able to pay for access to premium content, services, or products.

By combining strategic planning with valuable insights, you can succeed in the competitive blogging world and turn your passion into a valuable income stream.

The post The Future of Blog Monetization in 2024: Key Trends and Techniques to Maximize Your Earnings appeared first on CSS Author.