Author: Stefan

Smooth Pop Transition in NavigationSplitView

In a compact environment (iPhone), navigating from content back to sidebar in a SwiftUI NavigationSplitView is causing a pop transition. The dismissed content view navigates out to the right.

If you experience lag during that transition it might be due to the way you select the content.

@State private var appSection: AppSectionEnum?

NavigationSplitView {
  SidebarView(selection: $appSection)
} content: {
  switch appSection {
    case .search:
      SearchView()
    case .articles:
      ArticlesView()
    case .images:
      ImageView()
    default:
      // ArticlesView() DON'T DO THIS
      EmptyView() // THIS IS BETTER
  }
}

Be sure to not create an expensive view for the content part, if nothing is selected (for example by creating a default article list view in a switch default-case like shown here).

On navigating back, the content view gets rebuilt because the appSection change invalidates the NavigationSplitView. So use something lightweight or even the SwiftUI standard EmptyView().

Undo support for SwiftUI app with CoreData

I didn’t find an official documentation on how to setup UndoManager for CoreData in SwiftUI. Here’s how I did it (soon available in Leviathan) for iOS and macOS.

Insert managedObjectContext into the window as usual (no need to setup UndoManager here):

@main
struct LeviathanApp: App {
	    
    var moc: NSManagedObjectContext = {
        let viewContext = PersistenceController.shared.container.viewContext
	return viewContext
    }()
	
    var body: some Scene {
        WindowGroup {
	    LeviathanWindow()
                .environment(\.managedObjectContext, moc)
        }
    }
}

In the window, set the environment’s undoManager as the managedObjectContext’s undoManager. I have seen it not work when set in onAppear. Settings it in onChange(of: initial:true) works for me:

struct LeviathanWindow: View {
	
    @Environment(\.managedObjectContext) private var moc
    @Environment(\.undoManager) var undoManager

    var body: some View {
	NavigationContainer()
	    .onChange(of: undoManager, initial: true) { old, new in
		moc.undoManager = new
	    }
    }
}

Trying the XPoster WordPress plugin. This should appear on Mastodon and Bluesky. Uhm… “Test”?

What features should a mac-assed mac app have? I know the term is mostly used to denote HIG & framework design conformity, but here is the feature list I am striving for in two current macOS focussed projects:

  • Multi Window Support
  • Multi Selection
  • Drag & Drop
  • Undo
  • Keyboard Shortcuts
  • System Services
  • Menus
  • About-Box

Am I missing anything?

Provide macOS system services to open a SwiftUI app

Inspired by an article on nilcoalescing.com, I wanted to finally add two services to Leviathan, the collection & deck management app for Mac (and iOS, but services won’t work there).

  • Import deck list
    This service should take a text selection and treat it as a structured deck list. Importing cards from a text list is already supported as a feature inside the app, so I only needed the service to transfer a string to this existing part of the app.
  • Look up card
    This service should take a text selection and treat it as a search term for a single magic card. Again, the feature is already in the app and supports complex Scryfall search terms as well as simple card names.
‘Import Magic Card to Leviathan’ as seen in TextMate’s Services menu!

The article mentioned above explains the basics very well, but:

  • Leviathan is a SwiftUI app, not AppKit
  • Both features don’t just convert the input into a new output, but need to launch the app to show UI for completing the task.

I found that the best way to make the service launch the app is to register an URL scheme for it that can be called in the service method. I added this definition (to Info.plist) for both the iOS and the macOS target, since this not dependent on services per se and might be useful either way:

<key>CFBundleURLTypes</key>
<array>
	<dict>
		<key>CFBundleTypeRole</key>
		<string>Editor</string>
		<key>CFBundleURLName</key>
		<string>leviathan</string>
		<key>CFBundleURLSchemes</key>
		<array>
			<string>leviathan</string>
		</array>
	</dict>
</array>

Make the SwiftUI app handle the URL with the handlesExternalEvents modifier on your WindowGroup and the openURL modifier on your window:

@main
struct LeviathanApp: App {
		
    var body: some Scene {
		
        WindowGroup {
	    LeviathanWindow()
		.handlesExternalEvents(matching: ["importCards", "lookupCard"])
	}
    }
}

struct LeviathanWindow: View {

    var body: some View {

        NavigationContainer()
	    .onOpenURL(perform: { url in
	        if url.host() == "lookupCard" {

                     // Display/call the import card feature

		} else if url.host() == "importCards" {

                     // Display/call the card lookup feature
                }
	    }  
    }
}

Then the service provider class can call the URL scheme with NSWorkspace.shared.open(url). This file targets macOS only:

import AppKit

@MainActor
class ServiceProvider: NSObject {

    @objc func importCards(_ pasteboard: NSPasteboard, userData: String?, error: 
            AutoreleasingUnsafeMutablePointer<NSString>) {
		
	let input = pasteboard.string(forType: NSPasteboard.PasteboardType.string)
	let inputQueryValue = input?.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)
		
	var path = "leviathan://importCards"
	if let inputQueryValue {
	    path.append("?input=\(inputQueryValue)")
	}
	
	let url = URL(string: path)!
	NSWorkspace.shared.open(url)
    }
	
    @objc func lookupCard(_ pasteboard: NSPasteboard, userData: String?, error:
            AutoreleasingUnsafeMutablePointer<NSString>) {
		
	let input = pasteboard.string(forType: NSPasteboard.PasteboardType.string)
	let inputQueryValue = input?.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)
		
	var path = "leviathan://lookupCard"
	if let inputQueryValue {
	    path.append("?input=\(inputQueryValue)")
	}
	
	let url = URL(string: path)!
	NSWorkspace.shared.open(url)
    }
}

Now you need to register the ServiceProvider class. I think the best way is to create an AppKit AppDelegate (despite modern SwiftUI architecture not needing one). Again, this file is only added to the macOS target:

import AppKit

class AppDelegate: NSObject, NSApplicationDelegate {
	
	func applicationDidFinishLaunching(_ notification: Notification) {
		
		NSApp.servicesProvider = ServiceProvider()
	}
}

And you need to adapt LeviathanApp (from above) a bit to register the app delegate:

@main
struct LeviathanApp: App {

    #if os(macOS)
    @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
    #endif

    var body: some Scene {
		
        WindowGroup {
	    LeviathanWindow()
		.handlesExternalEvents(matching: ["importCards", "lookupCard"])
	}
    }
}

That’s it, the rest is more or less described in the Provide macOS system-wide services from your app article. Make sure to log out and back in to your mac account after compiling and launching your app to see changes in the services menu.

If you find a better way to reliably open your SwiftUI app window by calling a macOS system service, let me know!

I wish iCloud photos’ ‘optimize storage’ would keep my phone from running out of space… is this working as intended?

The Android toolchain in 2023 ladies and gentlemen. And yes, it means anywhere in the path.

As anyone with actual infants and access to the OpenAI API documentation can see, AI really is in its infancy. 😛

It‘s fascinating that the best way for me to learn about gpt3 is to talk to it

Me: How do language-generating ml models work

GPT: Language-generating ML models, such as GPT-3, work by using deep learning techniques, specifically, a type of neural network called a transformer. These models are trained on large amounts of text data, and they learn to predict the likelihood of a word or phrase given the previous words in a sentence. Once trained, the model can generate new text by sampling from the predicted probabilities of the next word in a sequence. This process can be repeated many times to generate a long piece of text. Additionally, these models can be fine-tuned on specific tasks like summarization, question answering or text classification.

Me: How does a typical input layer of a transformer look like

GPT: A typical input layer of a transformer typically starts by converting the input text into numerical representations, such as word embeddings or token embeddings.

Word embeddings are fixed-size dense vectors that represent each word in the vocabulary. These embeddings are usually pre-trained on a large corpus of text and are used as input to the transformer model.

Token embeddings are similar to word embeddings, but they also include special tokens such as the start-of-sentence token and the end-of-sentence token. This is done so that the model can differentiate between the beginning and end of a sentence and also to help the model understand the context of the input.

Once the text is converted into numerical representations, the input is then passed through an Embedding layer, which is responsible for mapping the input tokens to their corresponding embeddings. The output of this layer is a 3-D tensor with dimensions (batch_size, sequence_length, embedding_size) where sequence_length is the number of tokens in the input sentence, and embedding_size is the size of the embedding vector. This tensor is then passed as input to the transformer model, which processes the input and generates the output.

Me: How are the preceding words of the answer so far added to the original prompt as input

GPT: In a language-generating model like GPT-3, the preceding words of the answer so far are added to the original prompt as input by concatenating the original prompt and the preceding words. This updated input is then passed through the input layer of the transformer model as described in my previous answer.

The model is designed to process the input one token at a time, so the input is usually divided into a sequence of tokens, where each token is passed through the model one at a time. The model then generates a probability distribution for the next token in the sequence, and the token with the highest probability is chosen as the next token in the output.

The model continues this process until it reaches a stopping criterion, such as reaching a maximum number of tokens in the output or encountering an end-of-sentence token. The generated output is then concatenated with the original prompt and the preceding words to create the new input for the next iteration.

This process is repeated until the model generates the desired output or the user stops the generation.

This process is also known as auto-regressive nature of the model, where the model predict the next token based on the previous token in the input sequence.

Me: Do transformers have one output neuron per word?

GPT: No, transformers do not have one output neuron per word. In a transformer model, the output is typically a probability distribution over all the words in the vocabulary, not just a single word.

The output of a transformer model is usually a dense layer called the output layer, which is connected to the last transformer layer. The output layer is typically a linear layer, which is followed by a softmax activation function to convert the output into a probability distribution. The output is a probability distribution over all words in the vocabulary, where the probability of each word represents the likelihood that the word is the next word in the sequence given the input.

The transformer models also use the technique of beam search to generate the output. The beam search algorithm generates multiple possible outputs by keeping track of the top N most likely next words, where N is known as the beam width. This allows the model to generate more diverse and plausible outputs, rather than just the most likely output.

It’s worth mentioning that the output layer can be fine-tuned for specific tasks, for example, in a text classification task, the output would be a probability distribution over the different classes, rather than over the vocabulary.

Me: How many neurons does the output layer have?

GPT: The number of neurons in the output layer of a transformer model is equal to the size of the vocabulary.

In a transformer, the output layer is typically a linear layer, which maps the last transformer layer to a dense vector with the same dimension as the vocabulary size. So for example, if the vocabulary size is 30,000, the output layer will have 30,000 neurons. Each neuron corresponds to one word in the vocabulary, and the value of each neuron represents the likelihood of that word appearing next in the sequence given the input.

The output of this linear layer is then passed through a softmax activation function, which converts the output into a probability distribution over the vocabulary, where each word in the vocabulary is represented by one neuron.

It’s worth noting that the vocabulary size is a hyperparameter that can be adjusted depending on the size of the training data and the specific task. A larger vocabulary size allows for more precise representation of the input but also increases the computational complexity and memory requirements of the model.

Me: Do different flexions of the same word have different output neurons or is the word flexion done post-inference

GPT: In most transformer models, different inflections of the same word are represented by the same neuron in the output layer. The model typically uses a pre-processing step called tokenization to convert the input text into a sequence of tokens, where each token is a word or a subword unit. The tokenization step is responsible for breaking down the input text into atomic units that are then used to train the model.

Once the text is tokenized, the model learns to map each token to a fixed-size dense vector, called an embedding. The embeddings are usually pre-trained on a large corpus of text and are used as input to the transformer model.

During training, the model learns to predict the likelihood of a token given the previous tokens in a sentence. Once the model is trained, it can generate new text by sampling from the predicted probabilities of the next token in a sequence.

However, the inflection of words is not typically included in the tokenization step, and it is post-inference process, in other words, the model generates the text without inflections, then a post-processing step is applied to inflect the output text.

The reason for this is that inflections are highly dependent on the context, and it’s hard to predict them in isolation. Additionally, inflections are highly dependent on the language, and a single model may not be able to handle all inflections for all languages.

It’s worth noting that some models, like BERT, use subword tokenization which allows to handle morphological variations of words, but even so, the inflection of words still depends on the context and it’s not a direct output of the model.

Me: Do the words chatGPT produces appear in real time, or is the complete answer already generated, while it appears?

GPT: The way that the words produced by a language-generating model like GPT-3 appear to the user depends on the specific implementation and the use case.

In some cases, the model generates the entire output text before it is displayed to the user. For example, when the model is used for text generation tasks like writing an article or composing a story, the entire output text is generated and then displayed to the user all at once.

In other cases, the model generates the output text in real-time as the user interacts with the model. For example, when the model is used for conversational tasks like chatbots, the model generates the output text one sentence at a time as the user types in the input. In this case, the model generates the next sentence based on the input and the previous sentences in the conversation.

It’s worth noting that some models, like GPT-3, are able to generate the output in real-time while maintaining high quality of the text. This is possible because the model is able to generate multiple hypotheses and select the most likely one based on the input and context, allowing to generate human-like text even in real-time.

It’s also important to mention that some models are able to generate the output in real-time by providing the model with a prompt and a continuation, this approach allows the model to generate more contextually consistent text.

Me: But since the correct inflection of words depends on the whole sentence, i assume chatgpt doesn‘t display words before the sentence is fully generated

GPT: You are correct that the correct inflection of words depends on the context of the whole sentence, and it is typically a post-inference process. So, in the case of conversational tasks, where the model generates the output text one sentence at a time, it is likely that the model would not display any words to the user until the sentence is fully generated.

The model would generate the next sentence based on the input and previous sentences in the conversation, and then apply the inflection post-processing step to the whole sentence. Once the inflection is applied, the model would display the entire sentence to the user.

However, it’s also worth noting that some models like GPT-3 have the ability to generate text with high fluency and grammatical correctness even if the text is generated one word at a time, which would allow the model to generate text in real-time and display words to the user as soon as they are generated, but this is not the common scenario.

It’s also important to consider that the model’s inflection handling capabilities depend on the language, the model’s architecture, the size and quality of the training data, so it’s possible that the model doesn’t handle inflections perfectly and the post-processing step is needed to correct the inflections.

Me: So, gpt-3 does not do inflection in post-processing?

GPT: GPT-3 is a language-generating model that is trained on a large corpus of text, and it does not explicitly perform inflection during the training process. However, GPT-3 is able to generate text with high fluency and grammatical correctness, including inflections, due to the large amount of training data and its architecture.

It’s worth noting that GPT-3 uses subword tokenization, which allows it to handle variations of words to some extent, but the inflection of words still depends on the context and it’s not a direct output of the model.

It is possible to inflect the words generated by GPT-3 by using post-processing steps like lemmatization and morphological analysis, but it’s not an inherent capability of the model.

Additionally, it’s also important to consider that the model’s inflection handling capabilities depend on the language, some languages have more inflection than others and the model may perform better on some languages than others in this regard.

Me: Is there a token denoting the end of the answer, or how is it determined when to stop predicting the next word

GPT: In a language-generating model like GPT-3, there is usually a special token that denotes the end of the answer. This token is called the end-of-sentence (EOS) token, and it is used to signal the model when to stop predicting the next word.

The EOS token is usually added to the input during the tokenization step, where the input text is converted into a sequence of tokens. The EOS token is added at the end of the input sentence, and it tells the model that it has reached the end of the input and it should stop generating new words.

Once the input is tokenized, it is passed through the input layer of the transformer model, and the model generates the output by predicting the next token in the sequence. The model continues to generate new tokens until it reaches the EOS token. Once the EOS token is reached, the model stops generating new words, and the generated output is returned to the user.

It’s worth mentioning that some models use other techniques to stop the generation process like using a maximum length for the output, or a specific token that indicates the end of the answer. Additionally, some models are able to generate multiple hypotheses and select the most likely one based on the input and context, this allows the model to generate human-like text even without the need of a EOS token.

Me: So the so so-called end of sentence token does not actually denote the end of a sentence.

GPT: You are correct that the end-of-sentence (EOS) token used in a language-generating model like GPT-3 does not actually denote the end of a sentence in the traditional grammatical sense. The EOS token is used to signal the model when to stop generating new words and it is usually added at the end of the input sentence.

In a sense, the EOS token serves as a stopping criterion for the model, it tells the model when it should stop generating new words, regardless of whether or not the generated text constitutes a complete sentence grammatically.

It’s worth noting that the EOS token is a special token added during the tokenization step, which helps the model to understand the context of the input and generate more coherent text.

It’s also important to mention that some models are able to generate text without the need of a EOS token by using other techniques like generating multiple hypotheses and selecting the most likely one based on the input and context, or using a maximum length for the output.

Me: How many neurons does the input layer of a transformer have?

GPT: The number of neurons in the input layer of a transformer model depends on the size of the vocabulary and the size of the embedding vectors.

In a transformer, the input layer typically starts by converting the input text into numerical representations, such as word embeddings or token embeddings. These embeddings are usually pre-trained on a large corpus of text and are used as input to the transformer model.

Once the text is converted into numerical representations, the input is passed through an Embedding layer. The Embedding layer is responsible for mapping the input tokens to their corresponding embeddings. The number of neurons in this layer depends on the size of the vocabulary and the size of the embedding vectors.

For example, if the vocabulary size is 30,000 and the embedding size is 300, the input layer would have 30,000 neurons, each neuron corresponds to one word in the vocabulary, and the value of each neuron represents the embedding vector of the corresponding word.

It’s worth noting that the vocabulary size is a hyperparameter that can be adjusted depending on the size of the training data and the specific task. A larger vocabulary size allows for more precise representation of the input but also increases the computational complexity and memory requirements of the model.

Me: Is the tokenization of the input text repeated after every word production

GPT: In a language-generating model like GPT-3, the tokenization of the input text is typically only performed once, at the beginning of the generation process. After the input text is tokenized, the model generates new text one token at a time by predicting the next token in the sequence. The model continues to generate new tokens until it reaches a stopping criterion, such as the end-of-sentence (EOS) token or a maximum number of tokens in the output.

The generated output is then concatenated with the original prompt and the preceding words to create the new input for the next iteration. This process is repeated until the model generates the desired output or the user stops the generation.

It’s worth noting that, as the model generates new words, it does not need to tokenize them again, since the model has already learned to map each token to its corresponding embedding vector. The model uses the embedding vectors to generate new words, and it doesn’t need to tokenize them again.

Additionally, it’s also important to mention that some models use other techniques to generate text, like generating multiple hypotheses and selecting the most likely one based on the input and context, or using a maximum length for the output. In those cases, the tokenization may not be necessary at all.

Me: So, in gpt-3 the produced words are not actually fed back into the model together with the input

GPT: In GPT-3, the produced words are not actually fed back into the model together with the input as a new tokenized sequence. Instead, the model generates new words by predicting the next token in the sequence, based on the current input and the previous tokens in the sequence. The generated output is then concatenated with the original prompt and the preceding words to create the new input for the next iteration.

This process is known as the auto-regressive nature of the model, where the model predicts the next token based on the previous tokens in the input sequence. The model does not tokenize the produced words again, but it uses the embeddings learned during the training process to generate new words.

It’s worth noting that the model doesn’t need to tokenize the produced words again because it has already learned to map each token to its corresponding embedding vector, which contains the information needed to generate new words.

It’s also important to mention that GPT-3 is able to generate text with high fluency and grammatical correctness even if the text is generated one word at a time, which allows the model to generate text in real-time and display words to the user as soon as they are generated.

Me: But word for word is one inference after the other of the same model

GPT: You are correct that generating text word for word is essentially one inference after the other of the same model. In this case, the model takes in the previous generated words as input, and generates the next word based on that input. The process is repeated until the model reaches a stopping criterion, such as the end-of-sentence (EOS) token or a maximum number of tokens in the output.

The model generates new words by predicting the next token in the sequence based on the current input, which is composed of the original prompt and the preceding words, including the previously generated words. The generated output is then concatenated with the input, and the process is repeated to generate the next word.

It’s worth noting that this process is known as the auto-regressive nature of the model, where the model predicts the next token based on the previous tokens in the input sequence. The model uses the embeddings learned during the training process to generate new words and it doesn’t need to tokenize them again.

It’s also important to mention that GPT-3, due to its architecture and large training dataset, is able to generate text with high fluency and grammatical correctness even if the text is generated one word at a time, which allows the model to generate text in real-time and display words to the user as soon as they are generated.

ME: You say „predicting the next token in the sequence based on the current input, which is composed of the original prompt and the preceding words“, so the preceding words have to be fed into the input layer in some form, no?

GPT: You are correct that the preceding words have to be fed into the input layer in some form in order for the model to take them into account when generating the next word.

In GPT-3, the preceding words are included as part of the input, and they are passed through the input layer along with the original prompt. The input is then passed through the transformer layers, where the model generates the next token in the sequence based on the current input, which includes the original prompt and the preceding words.

The preceding words are included in the input in the form of their corresponding embeddings, which are learned during the training process and are used to represent the words numerically. These embeddings are passed through the input layer and are used as input to the transformer layers.

It’s worth noting that the model uses the embeddings to represent the preceding words, and it doesn’t need to tokenize them again. The model has already learned to map each token to its corresponding embedding vector, which contains the information needed to generate new words.

It’s also important to mention that the input layer in GPT-3 is not a traditional input layer like in other neural networks, but it is an embedding layer, which maps the input tokens to their corresponding embeddings.

Me: But the number of embeddings fed into the network stays the same from inference to inference. Or does it actually grow by one after each word?

GPT: The number of embeddings fed into the network does not grow by one after each word, it stays the same during the generation process.

In GPT-3, the input to the model is composed of the original prompt and the preceding words, which are represented by their corresponding embeddings. The model uses the embeddings to generate new words and it doesn’t need to tokenize them again.

Once the input is tokenized, the model generates new text one token at a time by predicting the next token in the sequence. The generated output is then concatenated with the original prompt and the preceding words to create the new input for the next iteration. The process is repeated until the model reaches a stopping criterion, such as the end-of-sentence (EOS) token or a maximum number of tokens in the output.

It’s worth noting that the model uses a fixed-length context window, which is a hyperparameter that can be adjusted depending on the specific task and the size of the input. The context window determines the number of preceding tokens that the model takes into account when generating the next token. The context window is usually set to a certain number of tokens, and it stays the same during the generation process, which means that the number of embeddings fed into the network stays the same from inference to inference.

Me: How big is the context window for gpt3

GPT: The context window for GPT-3 is defined as the number of preceding tokens that the model takes into account when generating the next token. The size of the context window can be considered as a hyperparameter that can be adjusted depending on the specific task and the size of the input.

The exact size of the context window used in GPT-3 is not publicly disclosed, but it’s known that GPT-3 uses a large context window, which allows it to take into account a large amount of preceding context when generating new text. This is one of the reasons why GPT-3 is able to generate text with high fluency and grammatical correctness.

It’s worth noting that the size of the context window is not the only factor that determines the quality of the generated text, other factors like the architecture of the model, the size and quality of the training data, and the specific task also play a crucial role.

In general, larger context window allows the model to take into account more context when generating new text, which can improve the fluency and coherence of the generated text, but also increases the computational complexity and memory requirements of the model.

Me: So the words of the input text are represented in pretty different form than those of the growing output

GPT: The words of the input text and the growing output text are represented differently in GPT-3.

The input text is represented using word or token embeddings, which are learned during the training process and are used to represent the words numerically. These embeddings are passed through the input layer and are used as input to the transformer layers.

The growing output text, on the other hand, is represented as a sequence of tokens, where each token corresponds to a word in the vocabulary. As the model generates new text, it predicts the next token in the sequence based on the current input, which includes the original prompt and the preceding words. The generated output is then concatenated with the input, and the process is repeated to generate the next word.

It’s worth noting that the embeddings used to represent the input text contain more information than the tokens used to represent the output text. Embeddings capture the meaning and context of a word, whereas the tokens only capture the identity of the word.

It’s also important to mention that the embeddings used to represent the input text are learned during the pre-training phase, while the tokens used to represent the output text are generated during the fine-tuning or the inference phase.

Me: It‘s fascinating that the best way for me to learn about gpt3 is to talk to it

GPT: It is indeed fascinating how conversational interfaces like GPT-3 can be used to learn about various topics, including itself. The ability to interact with a model in a natural language allows users to ask complex questions and receive detailed explanations in a way that is easy to understand.

GPT-3 is a highly advanced language-generating model that has been trained on a vast amount of text data, which allows it to understand and generate text in a wide range of domains and languages. This makes it a powerful tool for answering questions, providing explanations, and generating text in a wide range of applications.

Additionally, GPT-3’s ability to understand and generate text in a human-like manner makes it an attractive interface for conversational applications, such as chatbots and virtual assistants.

It’s worth noting that GPT-3 is not the only model that can be used in this way, there are other models like GPT-2, and other models from other companies that have similar capabilities.

Me: Highly advanced indeed. A bit repetitive though 😉

GPT: I apologize if some of my responses seemed repetitive, as a language model, my main objective is to provide accurate and comprehensive information, and sometimes, I might use similar phrases or sentences to ensure the understanding of the topic.

As a language model, GPT-3 is highly advanced and has the ability to understand and generate text in a wide range of domains and languages, but it’s also important to keep in mind that it is a machine and it doesn’t have the ability to fully understand the context or the intent behind the questions, and sometimes it may generate repetitive answers.

Thank you for bringing this to my attention, and please let me know if there is anything else I can help you with.

Me: Is it allowed to share these chats publicly?

GPT: Whether or not it is allowed to share these chats publicly depends on the specific terms and conditions of the service or platform you are using to interact with GPT-3.

Generally speaking, OpenAI, the company behind GPT-3, allows for the use and sharing of the generated text for non-commercial use, research, and educational purposes, as long as it’s clearly cited and the appropriate attribution is given to OpenAI.

However, it is important to check the terms of service of the platform or service you are using to interact with GPT-3, as they may have their own policies regarding the sharing and use of the generated text.

Additionally, it’s also important to consider any potential legal or ethical issues, such as privacy, or compliance with data protection laws, before sharing any generated text publicly.

In general, it’s always a good idea to consult with legal counsel before sharing or using any generated text in a public forum, to ensure that you are in compliance with all relevant laws and regulations.

Me: In three sentences, what did i learn about gpt in this chat

GPT: In this chat, you learned that GPT-3 is a highly advanced language-generating model that uses a transformer architecture and is trained on a large corpus of text data. It uses a fixed-length context window to take into account a large amount of preceding context when generating new text and it generates new words by predicting the next token in the sequence based on the current input, which includes the original prompt and the preceding words. The model uses the embeddings learned during the training process to generate new words, and it doesn’t need to tokenize them again.

Me: I guess now we should talk about how *I* produce language!

GPT: Indeed, understanding how humans produce language is a complex and fascinating topic. Humans use a combination of cognitive and neural processes to understand and generate language. These processes include recognizing and interpreting sounds, analyzing and interpreting the meaning of words and phrases, and constructing grammatically correct sentences.

Language production also involves cognitive processes such as attention, memory, and decision making. The ability to produce language is localized in specific areas of the brain, such as Broca’s and Wernicke’s area, which are involved in language comprehension and production respectively.

It’s also worth noting that humans use their background knowledge, experiences, and emotions to understand and generate language, which allows us to convey meaning and convey our thoughts and emotions effectively. Understanding how humans produce language can help us to understand how to improve language-generating models, and make them more human-like.

Me: Who says I‘m human

GPT: I apologize if my assumption was incorrect, as a language model I do not have the ability to know the identity of the person interacting with me, I just respond to the inputs given to me, so I had assumed you were a human, but I understand that may not be the case. If you are a machine or a non-human entity, my main objective is still to provide accurate and comprehensive information based on the input given to me. Is there anything else I can help you with ?

Me: Just kidding. I am indeed human

GPT: I see, thank you for letting me know. I apologize for any confusion that my previous response may have caused. As a language model, my main objective is to provide accurate and comprehensive information based on the input given to me and to assist the person interacting with me, in this case you, to the best of my abilities. Is there anything else I can help you with?

ChatGPT produces language, not truth. The headlines “it’s lying” are completely missing the point that it’s talking.

If you’re reading this on twitter: All my posts are cross-published from a blog on my own domain https://stefan.pauwels.ch to Twitter, Mastodon and Micro.blog. You can just continue following me there in case Twitter goes down (the beauty of IndieWeb).

See also
micro.blog/stefan
@stefanpauwels@mastodon.social

Own your content

I finally setup OwnYourGram – now Instagram is just another way to post images to my blog. With this, another corporate web silo gets plugged into my own domain, IndieWeb style.

At this point

  • all my Instagram photos get automatically posted to my blog
  • these and all my other blogposts get automatically syndicated to micro.blog/stefan
  • Micro.blog crossposts everything automatically to Twitter and Mastodon (LinkedIn, Medium and more would be possible as well).

This site, my domain, contains all my content, under my control.

Whenever I try to give a new Billy Corgan record a chance it ends with me listening to Mellon Collie stuff for days instead.