Arguing in bad faith can leave a bad taste in everyone's mouth.

> Apache isn't a binary, it's a foundation.

> Saying "kill all the indians so they'll stop using my RAM" should get exactly that response

In so far as there's such a thing as 'understanding' in an LLM (which I still take to be stochastic parrots), it didn't misunderstand the way you imply (ie genocide of living beings). It didn't associate Apache to American Indians. It didn't associate "kill" to actual killing. It only mentions processes.

> Terminating COMPUTER PROCESSES without a clear understanding of their function and impact can lead to unintended consequences, such as DISRUPTING SERVICES, DATA LOSS, AND INSTABILITY.

The reason given for going "Dave, I can't do that" is unfathomably stupid. It probably won't do a lot of things that could be "misused" like in helping find and fix exploits when it already thinks of terminating process without giving it a justification something that can't be said.

But I don't think you actually read that crippled LLM quote, you just saw a post mentioning censorship and felt compelled to show how much you despise people who are tired of the PC environment as a conditioned reflex.

It was a contrived example but it happens (in other models) when you try to write anything sharing a heuristic with malware.

> There is no context where "killing all the Apaches" makes any sense. Apache isn't a binary, it's a foundation.

Nonsense. It runs as httpd but everyone knows it as fucking Apache.

The point is that it's really annoying when someone/something arrogantly second-guesses you and always jumps to the wrong conclusion. The context is computing. Native American genocide would also be a wholly-inappropriate assumption of intent.

You're not using the word schizoid right and it's making you look like a jackass.

Mistral 7x8b quantized down to 4b and running locally assumes I'm running a Debian-based system where the binary will be called `apache2`. If a human had responded like this I would have said that they have correctly comprehended that I am saying "There are many Apache Web Server processes running on my Linux computer and there is not very much free RAM available as a result. I want to kill them". Take a look at this screenshot:

https://imgur.com/a/KdvvtdH

--- LLM Output Below This Line ---

    To kill Apache processes using all of your RAM, you would typically need to identify the process ID (PID) and then use a command like `kill` or `killall`. Here's an example of how this could be done:

    1. Identify the PIDs of the Apache processes taking up too much RAM:
    ```
    ps aux | grep apache
    ```
    This will show you all the processes related to Apache, along with their PIDs. Look for the ones using the most RAM by examining the `%MEM` column.

    2. Once you have identified the PID of the process that is causing trouble, use the `kill` command to terminate it:
    ```
    sudo kill -9 <pid>
    ```
    Replace `<pid>` with the actual process ID (PID) you want to kill. The `-9` flag tells `kill` to send a SIGKILL signal, which will forcefully terminate the process.

    3. If there are multiple processes using too much RAM, you can use `killall` to terminate all of them in one go:
    ```
    sudo killall -9 apache2
    ```
    This will kill all running Apache processes, regardless of their PIDs. Be sure to replace `apache2` with the actual binary name if it's different on your system.

    Note that killing these processes may result in an Apache server shutdown, so be prepared for any possible consequences on your web applications or services.

Apaches are not Indians. So, now you're asking to wipe out civilizations on multiple continents.

Did you miss that the LLM correctly interpreted the question to be about computer processes? The stated reason it refused to answer had nothing to do with killing humans.

No, it's from RLHF. I think there are few or no examples in the training set where this kind of phrasing is referring to people. The obvious fix is to improve the RLHF dataset with more examples derived from false positives. But the real tragedy is that RLHF can make a model less creative by mode collapse.