What’s the Big Deal About LLMs?

LLMs are computer models that understand and create human language. But why are they so special? Imagine trying to guess the next word in a sentence your friend is saying—that’s basically what LLMs do, but they do it on a much larger scale. They can write whole essays, answer complex questions, and even translate languages!

• LLMs use patterns in language to predict the next word.
• They’ve learned from huge amounts of text—like books, websites, and research papers.

Layers of AI: How Does AI Learn?

AI consists of multiple layers, each playing a unique role. Let’s break it down:

1. Artificial Intelligence (AI): This is the overarching concept of making machines capable of tasks that typically require human intelligence.

2. Machine Learning (ML): A subset of AI where machines learn from data. For instance, if you show a computer hundreds of images of cats and dogs, it will eventually learn to distinguish between the two.

3. Deep Learning: A more specialized part of ML that tackles more complex data, like images or language. This is where neural networks come in—systems loosely based on the human brain.

4. Large Language Models (LLMs): LLMs specialize in processing text and forming human-like responses, and that’s what we’ll explore in this article.

Machine Learning: A Simple Example

The purpose of Machine Learning is to find patterns in data. More specifically, it identifies relationships between inputs and outcomes.

Music Genres Example:

Imagine you want to tell the difference between two music genres: reggaeton and R&B.

• Reggaeton is known for its lively beats and danceable rhythms.
• R&B (Rhythm and Blues) is more soulful, often featuring both fast-paced and slow songs.

Suppose we have 20 songs. Each song has a tempo (how fast the song is) and an energy level. We’ve also labeled them by genre. When we plot the data, we notice that high-tempo, high-energy songs are usually reggaeton, while slower, low-energy songs are mostly R&B.

Machine Learning can automate the task of labeling genres based on these patterns, allowing us to predict the genre of new songs. This type of task is called classification, where the outcome can only be one of a fixed number of labels (like R&B or reggaeton).

The machine learns by finding a line that separates the two genres. Once it learns this, we can use the line to predict whether any new song belongs to reggaeton or R&B, based on its tempo and energy.

What if the Input is Text?

Now imagine a more complicated input: text. Let’s say we want to know whether a sentence has a positive or negative sentiment (emotion). This, too, is a classification task.

Turning words into something a computer can understand isn’t straightforward. We need to convert them into word embeddings, which are numerical representations that capture a word’s meaning. These word embeddings allow the machine to process the sentence as a sequence of numbers, which it can then use to make predictions.

Deep Learning: A Step Deeper

By now, we’ve seen that more complicated tasks (like analyzing text or images) require more powerful models. Enter Deep Learning.

Deep Learning uses neural networks to model complex relationships at scale. These networks have many layers, each processing information and passing it along to the next. You can think of them like stacks of mathematical functions that allow the machine to learn intricate patterns.

Neural networks are often described as being inspired by the human brain, but in reality, they’re quite different. Still, their basic structure—layers of connected units called neurons—lets them model very complicated relationships.

For instance, ChatGPT is based on a neural network that contains over 176 billion parameters (neurons), allowing it to process and generate human-like responses. Compare that to the human brain, which has around 100 billion neurons.

How Do LLMs Work?

Now that we understand neural networks, we can dive into LLMs.

Let’s say you type “The cat is…” into ChatGPT. The LLM tries to predict the next word: is the cat sleeping? Is the cat running? It makes this prediction based on the patterns it has learned from millions of sentences.

What is GPT?

GPT stands for Generative Pre-trained Transformer:

• Generative: The model is trained to generate text.
• Pre-trained: The model has already been trained on vast amounts of text data.
• Transformer: This is the specific neural network architecture used.

The transformer architecture is special because it helps the model focus on the most important parts of a sentence, much like how humans pay attention to key details in a conversation.

How LLMs Learn: The 3 Steps

LLMs learn in three stages:

1. Pre-Training:
   • The model reads huge amounts of text and learns to predict the next word. Think of it as a giant guessing game.
2. Fine-Tuning:
   • After the model learns to predict words, it’s refined using real-life questions and answers. This makes the LLM more helpful when responding to users.
3. Reinforcement Learning (RLHF):
   • Humans step in to correct the model’s mistakes, which teaches the model to provide more accurate answers.

Pre-Training:

During this phase, the model requires a huge amount of data to learn how to predict the next word. In this process, the model not only learns grammar and sentence structure, but also gains a broad understanding of various topics, along with some additional capabilities that we’ll discuss later.

But here’s a question: What are the potential issues with this kind of pre-training? There are several, but the main concern I want to highlight is related to what the model is actually learning.

Essentially, the model becomes good at generating continuous text on a given topic, but it doesn’t excel at responding to specific instructions or questions. The issue is that it hasn’t been trained to act like a helpful assistant.

For instance, if you ask a pre-trained LLM, “What is your first name?”, it might reply with, “What is your last name?” This happens because the model has encountered similar sequences in its training data (such as empty forms) and is simply trying to complete the pattern.

It struggles with following clear instructions because this type of structured conversation—where an instruction is followed by a relevant response—was not common in the data used for training. Platforms like Quora or StackOverflow might be closer examples of that structure, but they are rare compared to the vast variety of text the model was trained on.

Fine-Tuning:

This is where instruction tuning steps in. We take the pre-trained LLM, which has learned how to predict words, and teach it something new: how to follow instructions. Essentially, we’re doing the same thing as before—training the model to predict one word at a time—but now, we’re using a more curated dataset filled with high-quality instruction-response pairs.

In this phase, the model “un-learns” its habit of simply completing text and instead evolves into an assistant that understands and responds according to user instructions. The dataset used for this fine-tuning is much smaller than what we used in pre-training, and there’s a reason for that: creating these instruction-response pairs is costly, as they require human input, unlike the massive and inexpensive self-supervised data we used earlier. This stage is referred to as supervised instruction fine-tuning for that reason.

Some LLMs, like ChatGPT, go through an additional phase called reinforcement learning from human feedback (RLHF). We won’t dive too deep into it, but this phase works similarly to instruction tuning. The goal is to further align the model’s responses with human values and preferences. Early research suggests that RLHF plays a key role in helping LLMs reach, or even exceed, human-level performance. By blending reinforcement learning with language modeling, we’re seeing tremendous potential for improving LLMs far beyond what they can currently do.

Challenges with LLMs

Despite their abilities, LLMs face several challenges:

• Hallucinations: Sometimes, LLMs invent facts. For example, if you ask, “Who is the president of Mars?” the model might make up a name.

• Outdated Information: LLMs are trained on past data, so they might not know the latest events. Some models, like Bing Chat, solve this by retrieving up-to-date information from the internet before answering.

Why LLMs Keep Getting Smarter

LLMs improve because:

• They are trained on more data over time.
• They use increasingly larger neural networks (some with billions of parameters).

Cool LLM Abilities

• Zero-Shot Learning: LLMs can handle tasks they weren’t specifically trained for, like translating a sentence while using only words starting with “B.”

• Creative Responses: Ask ChatGPT to translate “The cat sleeps in the box” using only words that start with “f,” and it might respond with “Furry friend rests in cozy quarters.”

The Future of LLMs

As LLMs continue to improve, they’ll find their way into more applications:

• Search engines will provide smarter, more relevant results.
• Digital assistants like Siri or Alexa will have more natural conversations.
• Creative tools will help generate stories, essays, and much more.

Key Takeaways

• LLMs, like ChatGPT, predict words based on the vast amounts of text they’ve learned from.
• They are trained in three stages: pre-training, fine-tuning, and reinforcement learning.
• LLMs can handle a variety of tasks, from answering questions to generating creative text.

In the end, LLMs are transforming how we interact with technology. As they evolve, they’ll continue shaping the future of AI and our everyday digital experiences.

I hope this article helps you understand what LLMs are and how they work. It’s important that everyone, not just AI experts, has a voice in how AI develops and is used to benefit society. AI is part of our future, and it’s up to all of us to guide it responsibly.

This post is inspired by and references the article How Large Language Models Work from Andreas Stöffelbauer article in Meduim, and images used in the article are taken from there as well.

However, replacing Single with First is not always feasible, as these two methods serve different purposes and cannot always be interchanged. Despite their distinct functionalities, there are instances where they can be swapped.

The SingleOrDefault method does not always traverse “all” items of an Enumerable. ❌

If we call Single<T> or SingleOrDefault<T> without passing any Predicate, three scenarios can occur:

• If there are zero items, the default value of type T is returned.
• If there is exactly one item, item [0] of the Enumerable is returned.
• If there are more than one items, an error is thrown.

public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source)
{
  if (source == null)
    throw Error.ArgumentNull(nameof (source));
    
  if (source is IList<TSource> sourceList)
  {
    switch (sourceList.Count)
    {
      case 0:
        return default (TSource);
        
      case 1:
        return sourceList[0];
    }
  }
  else
  {
    using (IEnumerator<TSource> enumerator = source.GetEnumerator())
    {
      if (!enumerator.MoveNext())
        return default (TSource);
        
      TSource current = enumerator.Current;
      
      if (!enumerator.MoveNext())
        return current;
    }
  }
  
  throw Error.MoreThanOneElement();
}

When these methods are called with a Predicate, they traverse the Enumerable and during this process, three situations can arise:

• If no item matches the Predicate, the default value of T is returned.
• If one item is found, the traversal continues. If another matching item is found, an error is thrown immediately. This second item could be the next one (1+) or any subsequent item (N+1).
• If no additional matching items are found, the first matching item is returned.

public static TSource SingleOrDefault<TSource>(
      this IEnumerable<TSource> source,
      Func<TSource, bool> predicate)
{
  if (source == null)
    throw Error.ArgumentNull(nameof (source));
    
  if (predicate == null)
    throw Error.ArgumentNull(nameof (predicate));
    
  using (IEnumerator<TSource> enumerator = source.GetEnumerator())
  {
    while (enumerator.MoveNext())
    {
      TSource current = enumerator.Current;
      
      if (predicate(current))
      {
        while (enumerator.MoveNext())
        {
          if (predicate(enumerator.Current))
            throw Error.MoreThanOneMatch();
        }
        
        return current;
      }
    }
  }
  
  return default (TSource);
}

In conclusion ✅ :

SingleOrDefault<TSource>(this IEnumerable<TSource> source) → O(1)
    
SingleOrDefault<TSource>(
  this IEnumerable<TSource> source, Func<TSource, bool> predicate) → O(N)

Microsoft’s CoreFX Repo: Single.cs

Dispose Method in C#

The Dispose method serves a crucial purpose: to free unmanaged resources the Garbage Collector can’t handle itself. Simply put, it’s like a memory emancipator, liberating trapped memory spaces!

public class DisposeExample : IDisposable
{
    bool disposed = false;

    // Declare your Filestream object.
    private FileStream fileStream = null;

    // Implement dispose.
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                fileStream?.Dispose();
            }

            disposed = true; 
        }
    }
}

The Finalize Method Basics

In simple terms, Finalize method is a destructor provided by Microsoft’s Object class, a method that helps to tidy up a mess after a function party, specifically focusing on cleaning up unmanaged resources.

Consider the following example:

class FinalizeExample
{
    FileStream fileStream;

    // Constructor, opens a file named "temp.dat"
    public FinalizeExample()
    {
        fileStream = new FileStream("temp.dat", FileMode.Create);
    }

    // destructor
    ~FinalizeExample()
    {
        // File closing statement
        fileStream.Close();
    }
}

In this FinalizeExample class, we have an unmanaged resource nativeResource. The destructor, marked with a tilde (~), frees this unmanaged resource during finalization.

Dispose vs Finalize

The Dispose method, when called, immediately frees up resources, both managed and unmanaged. This bolsters the performance of your code since it relieves resources from further use, like giving your computer a power nap, so it’s ready to take on the next task. On the other hand: The Finalize, it is automatic and works during the GC process, but it’s laser-focused on resources that Dispose can’t touch. It’s like having a house cleaner who, after cleaning your house today, shows up unannounced next week just to double-check everything is in order!

Important Points Related To HashSet in C#

• The HashSet class implements the ICollection, IEnumerable, IReadOnlyCollection, ISet, IEnumerable, IDeserializationCallback, and ISerializable interfaces.
• In HashSet, the order of the element is not defined. You cannot sort the elements of HashSet.
• HashSet elements are always unique. In oder word, duplicate elements are not allowed
• It provides many mathematical set operations, such as intersection, union, and difference.
• A HashSet is a dynamic collection means the size of the HashSet is automatically increased when the new elements are added.
• In HashSet, you can only store the same type of elements.

Example:

// C# program to illustrate how to create hashset
using System;
using System.Collections.Generic;

class HashsetTest {

	// Main Method
	static public void Main()
	{

		// Creating HashSet
		HashSet<string> myhash1 = new ();

		// Add the elements in HashSet
		myhash1.Add("C");
		myhash1.Add("C++");
		myhash1.Add("C#");
		myhash1.Add("Java");
		myhash1.Add("Ruby");
		Console.WriteLine("Elements of myhash1:");

		// Accessing elements of HashSet
		foreach(var val in myhash1)
		{
			Console.WriteLine(val);
		}

		// Creating another HashSet
		// using collection initializer to initialize HashSet
		HashSet<int> myhash2 = new () 
        {   10,
		    100,
            1000,
            10000,
            100000
        };
				
		// Display elements of myhash2
		Console.WriteLine("Elements of myhash2:");
		foreach(var value in myhash2)
		{
			Console.WriteLine(value);
		}
	}
}

When I sit at the computer, I am completely unaware of the clock and time, there is a small software that collects information about what you are doing. and sends it to its server

Analyzing the time you spent on each software, it can help you to be more productive.

For example, #Visual Studio, #Notepad++ or #StackOverflow Websit, and #CodeProject website have a positive rating as a programmer.

And social networks, checking email during work time is a negative point

You can determine in your dashboard whether a certain software or a certain site has a positive score or not

And every week it gives you a report that this week your performance was so much and you were so active on Telegram

In short, it hurts me a lot

If you want to use it, you can download it from this website rescuetime

search: false

Note: search: false only works to exclude posts when using Lunr as a search provider.

To exclude files when using Algolia as a search provider add an array to algolia.files_to_exclude in your _config.yml. For more configuration options be sure to check their full documentation.

algolia:
  # Exclude more files from indexing
  files_to_exclude:
    - index.html
    - index.md
    - excluded-file.html
    - _posts/2017-11-28-post-exclude-search.md
    - subdirectory/*.html