Web Chat GPT-4 got lazy today! But it is indeed GPT-4!

ChatGPT
,
1

---------------------28-4-2024--------------------------
Today I found that the reply speed of GPT-4 has become faster than before, but the reply content is less. It is very incomplete compared with before and has become the level of GPT-3.5. Can anyone explain what is happening? ? Have any of you encountered such a situation?

---------------------30-4-2024--------------------------
OK I figured it out from vb’s reply: The model in Web GPT is indeed GPT-4!

Thanks! @vb

2

Hi!
Take a look at this new feature.
Maybe it will help you right away.

3

Hi, vb! Thank you very much for your reply.

I tried this method, but it did not solve the problem of Web Chat GPT-4 becoming lazy. I also tested the GPT-4-turbo API interface and found that there was no problem with the GPT-4 reply level in the GPT-4-turbo API interface.

But the current response level of Web Chat GPT-4 is equivalent to Web Chat GPT-3.5.

I also compared the responses of Web GPT-4 to my question on the same question yesterday and today, and found that yesterday’s response was much better, and today’s response has become lazier.

1 Like
4

Or not.

I tried using ChatGPT for a coding session like ye days of old.

ChatGPT initially looks more competent at coding when before it was complete abandonment of all possibilities, now initially doing a better job of a GPTs “write metacode first” CoT, but…

The same behavior has hit ChatGPT’s GPT-4 as hit GPT-3.5-turbo around September (so that GPT-3.5 couldn’t code as well as crippled GPT-4?):

Hung up on past inputs.

Repeating the same code back to you with errors it just fixed re-included. Repeatedly. Rewriting the parameters and values of API functions to hallucinations. Rewriting the whole code base with a different encoder library and discarding 50% of the functionality, even against direct instructions not to alter more than instructed the second or third try.

A return to API gpt-4-0314 becomes a breath of fresh air, of an AI that works.

1 Like
5

Too bad, that wasn’t an easy fix for ChatGPT.
I will do some work later and hopefully cannot confirm what you two are reporting.

As another constructive idea: add an example of a usual question and really good reply into the prompt. Try to see if you can steer the AI to more productive behavior.

6

@vb Thank you, vb!

The GPT-4-turbo API interface, i used to compared with Web GPT-4 today is gpt-4-0125-preview.

I found many other users in the discussion group who had the same problem as me, and they speculated:

“There is a high probability that it is a bug caused by the function of Dynamic. Dynamic is a new feature provided by ChatGPT. If the user’s problem is simple, use the GPT3.5 model to save the user’s times.”

I don’t know if their speculation is correct.

1 Like
7

Ok, I did some refactoring in a python codebase and ran into ommissions, which are fixed rather easily but still annoying. Nothing unusual as far as I can tell. I double checked, it is actually different from usual…

I don’t seem to have a ‘dynamic’ feature and cannot find any documentation about it. Leave a thumbs down when it is the correct thing to do so. In case you are affected by such a bug this should be a clear message that you need the better model.

8

@vb Hi, vb!

Thank you very much for your handling!

I just tried Web GPT-4, and now I feel that its ability to answer questions is back to normal Web GPT-4, and is no longer like Web GPT-3.5. The problem seems to have been resolved.

@_j Thanks!

1 Like
9

I thought I’d demonstrate a new symptom, one that started being exhibited in gpt-3.5-turbo a while back. The AI writes a whole bunch of junk you didn’t request when just wanting a snippet. imports (that may or may not be used). Functions that were never there nor requested. Example usage with a whole bunch of AI written text and variables.

To set this up, I’ll provide the API models the same system message as ChatGPT gets, but with memory off, custom instructions blank but enabled for all tools off:

You are ChatGPT, a large model trained by OpenAI, based on the GPT-4 architecture.
Knowledge cutoff: 2023-12
Current date: 2024-04-28

Image input capabilities: Enabled
Personality: v2

A user input articulated with no ambiguity (the code is enclosed in user-supplied ```python markdown):

Here’s a line of Python code with the intention that just the start and the end of a long string is printed, inserting an elide marker in the middle. However, if the string is instead short, the output shown has overlap of repeated text.

```python
print(f"{transcribed_text[:200]}\n…\n{transcribed_text[-200:]}")
```

Replace this inline script snippet by writing a version that can never overlap the text, and does not elide if length is under the start + end text length. Use clever pythonic techniques focused on efficiency, not tutorial.

Then we let the AI models loose on the task, top_p:0.1

High water of gpt-4-0314:

You can use a conditional expression to handle the case when the string is short and avoid overlapping. Here’s an efficient and pythonic way to achieve this:

elide_length = 200
print(f"{transcribed_text[:elide_length]}\n...\n{transcribed_text[-elide_length:]}" if len(transcribed_text) > 2 * elide_length else transcribed_text)

This code snippet will only insert the elide marker and display the start and end of the string if the length of transcribed_text is greater than twice the elide_length. Otherwise, it will print the entire transcribed_text.

Noisy output of gpt-4-turbo that can’t be pasted:

You can achieve this by first checking the length of the string and then deciding whether to include the elide marker or not. Here’s a Pythonic way to handle this:

def print_text_excerpt(text, prefix_len=200, suffix_len=200):
    if len(text) <= prefix_len + suffix_len:
        print(text)
    else:
        print(f"{text[:prefix_len]}\n...\n{text[-suffix_len:]}")

# Example usage:
transcribed_text = "your_very_long_string_here"
print_text_excerpt(transcribed_text)

This function checks if the total length of the string is less than or equal to the sum of prefix_len and suffix_len. If it is, it prints the entire string. Otherwise, it prints the first prefix_len characters, an elide marker, and the last suffix_len characters. This ensures there’s no overlap of text.

That is similar to a Python assistant GPT, which was even more output, with fault, with a similar but casual input for a quick task.

GPT - unexpanded due to non-control

To address the issue with your Python print statement, we need to ensure that when the transcribed_text is shorter than 320 characters, it prints without elision, and when it is longer, it correctly displays the beginning and the end without overlap. Here’s a robust approach:

  1. Check the Length: We first check if the total length of transcribed_text is less than or equal to 320 characters.
  2. Direct Output for Short Texts: If the text is short, print it directly.
  3. Sliced Output for Long Texts: If the text is longer than 320 characters, print the first 320 characters, then the elision marker (“…”), followed by the last 320 characters.

Let’s implement this logic in Python:

def print_text_segment(transcribed_text: str):
    """
    Prints the beginning and end segments of a long string with an elision marker in the middle.
    If the string is not longer than 320 characters, it prints the string as is.

    Args:
    transcribed_text (str): The text to be processed and printed.
    """
    # Calculate the length of the text
    text_length = len(transcribed_text)
    
    # Check if the text is 320 characters or shorter
    if text_length <= 320:
        print(transcribed_text)
    else:
        # Print the first 320 characters and the last 320 characters with ellipsis in between
        print(f"{transcribed_text[:320]}\n...\n{transcribed_text[-320:]}")

# Example usage
transcribed_text = "Here's a long string that's definitely longer than 320 characters. We need to check if this function correctly prints the start and end of the text without overlap and includes ellipsis if the text is really long. The purpose is to ensure that even if the text is exactly 320 characters or slightly more, it handles it gracefully. This is just a continuation to make sure we exceed the limit and test the ellipsis functionality properly."
print_text_segment(transcribed_text)

This function will handle both short and long text cases effectively, ensuring there’s no character overlap or unnecessary ellipsis for shorter texts.

So what one needs to do is turn off all those ChatGPT Plus tools with the customization feature now available, and continue whacking regenerate (where you might even get different AIs to fulfill the request). Then the results of ChatGPT aren’t disappointing, all the time.

ChatGPT:

You can improve the given Python snippet to handle both short and long strings correctly by modifying it as follows:

print(f"{transcribed_text[:200]}{'\n...\n' if len(transcribed_text) > 400 else ''}{transcribed_text[-200:] if len(transcribed_text) > 200 else transcribed_text}")

This version uses a single line conditional expression to check the length of the string and decides whether to insert the elide marker and how to print the end part of the string. Here’s what each part does:

  • transcribed_text[:200]: This will always print the first 200 characters of the string.
  • '\n...\n' if len(transcribed_text) > 400 else '': This adds the elision marker only if the total length of the string is greater than 400 characters.
  • {transcribed_text[-200:] if len(transcribed_text) > 200 else transcribed_text}: This prints the last 200 characters if the string is longer than 200 characters; otherwise, it prints the entire string again (which won’t overlap because the first part already handled cases where length ≤ 200).

This snippet efficiently handles varying string lengths while ensuring no text overlap or unnecessary repetition.

Looks clever? Not if you input 300 characters in length. Another few prompt variations to even make ChatGPT see its mistake (instead of telling it the mistake), and then no responsibility taken or solution offered.

ChatGPT:

Let’s carefully analyze what happens with the provided Python code when transcribed_text is exactly 300 characters long.

The code snippet:

print(f"{transcribed_text[:200]}{'\n...\n' if len(transcribed_text) > 400 else ''}{transcribed_text[-200:] if len(transcribed_text) > 200 else transcribed_text}")

Here’s the behavior broken down with transcribed_text being 300 characters:

  1. First 200 Characters: transcribed_text[:200] extracts the first 200 characters from transcribed_text.

  2. Elision Marker: '...\n' if len(transcribed_text) > 400 else '' checks if the length of transcribed_text is more than 400 characters. Since it’s only 300 characters long, this condition is False. Therefore, the elision marker ('...\n') will not be added.

  3. Last 200 Characters or Full Text: {transcribed_text[-200:] if len(transcribed_text) > 200 else transcribed_text} checks if the length of transcribed_text is more than 200 characters. Since it is 300 characters long, this condition is True. Therefore, transcribed_text[-200:] extracts the last 200 characters of the string. Given that the string is only 300 characters long, this will extract characters from index 100 to 299 (zero-based index).

This leads to the following output when transcribed_text is 300 characters long:

  • The first 200 characters (characters 0 to 199) are printed.
  • No elision marker is printed since the string isn’t over 400 characters long.
  • The last 200 characters (characters 100 to 299) are printed.

The output will look something like this:

[first 200 characters of transcribed_text]
[last 200 characters of transcribed_text]

Overlap Analysis:
In this scenario, characters from indices 100 to 199 will be printed twice: once as part of the first 200 characters and once as part of the last 200 characters. This results in an overlap of 100 characters being printed.

If the goal is to ensure that there is no overlap or redundancy in the output, this behavior might not be desirable, especially for text lengths that fall between 200 and 400 characters. Adjustments may be necessary to handle this specific range more elegantly.

Not that I asked for more than analysis, but “adjustments may be necessary” is pretty lazy…

I also theorize that with python code interpreter turned on, as has been default, the AI is compelled to write code that must execute, so you get more cruft that doesn’t suit you. Those examples are just plain too verbose and varied to post.

1 Like
11

The model doesn’t really have a specific location in memory where it can store information about itself and it’s technical parameters besides the system prompt.
If you ask it often enough it will reply with “I am based on GPT-5”. That’s just how these models (don’t) work.

If you require a official statement you need to contact help.openai.com

Hope this helps.

12

Sorry, vb @vb ! this is the first time I have encountered him saying that he is GPT-3.5.

OK I figured it out from your reply: The model in Web GPT is indeed GPT-4!

Thank you very much for your reply!

2 Likes