开发者视角看GLM-4-9B！Datawhale成员万字测评（二）

import time
from zhipuai import ZhipuAI

def get_completion(prompt:str, history=None):
    client = ZhipuAI(api_key="your api key") # 请填写您自己的APIKey

    if history is None:
        history = []

    history.append({"role":"user", "content":prompt})

    response = client.chat.asyncCompletions.create(
        model="glm-4-9b",  # 填写最新的模型
        messages=history,
    )
    task_id = response.id
    task_status = ''
    get_cnt = 0

    while task_status != 'SUCCESS' and task_status != 'FAILED' and get_cnt <= 40:
        result_response = client.chat.asyncCompletions.retrieve_completion_result(id=task_id)

        task_status = result_response.task_status
        time.sleep(2)
        get_cnt += 1

    return result_response.choices[0].message.content

To effectively leverage our pretraining data in Llama 3 models, we put substantial effort into scaling up pretraining. Specifically, we have developed a series of detailed scaling laws for downstream benchmark evaluations. These scaling laws enable us to select an optimal data mix and to make informed decisions on how to best use our training compute. Importantly, scaling laws allow us to predict the performance of our largest models on key tasks (for example, code generation as evaluated on the HumanEval benchmark—see above) before we actually train the models. This helps us ensure strong performance of our final models across a variety of use cases and capabilities.
We made several new observations on scaling behavior during the development of Llama 3. For example, while the Chinchilla-optimal amount of training compute for an 8B parameter model corresponds to ~200B tokens, we found that model performance continues to improve even after the model is trained on two orders of magnitude more data. Both our 8B and 70B parameter models continued to improve log-linearly after we trained them on up to 15T tokens. Larger models can match the performance of these smaller models with less training compute, but smaller models are generally preferred because they are much more efficient during inference.
To train our largest Llama 3 models, we combined three types of parallelization: data parallelization, model parallelization, and pipeline parallelization. Our most efficient implementation achieves a compute utilization of over 400 TFLOPS per GPU when trained on 16K GPUs simultaneously. We performed training runs on two custom-built 24K GPU clusters. To maximize GPU uptime, we developed an advanced new training stack that automates error detection, handling, and maintenance. We also greatly improved our hardware reliability and detection mechanisms for silent data corruption, and we developed new scalable storage systems that reduce overheads of checkpointing and rollback. Those improvements resulted in an overall effective training time of more than 95%. Combined, these improvements increased the efficiency of Llama 3 training by ~three times compared to Llama 2.
GLM4-9B 给出的翻译为：

class Solution:
    def maximumPrimeDifference(self, nums: List[int]) ->int:
        ans = 0
        lastp = -1
        for x in nums:
            if self.isprime(x):
                if lastp != -1:
                    ans = max(ans, x - lastp)
                lastp = x
        return ans

    def isprime(self, x: int) ->bool:
        if x < 2:
            return False
        for i in range(2, int(x ** 0.5) + 1):
            if x % i == 0:
                return False
        return True

class Solution:
    def maximumPrimeDifference(self, nums: List[int]) -> int:
        def is_prime(n):
            if n < 2:
                return False
            for i in range(2, int(n**0.5) + 1):
                if n % i == 0:
                    return False
            return True

        min_prime_index = float('inf')
        max_prime_index = float('-inf')

        for i, num in enumerate(nums):
            if is_prime(num):
                min_prime_index = min(min_prime_index, i)
                max_prime_index = max(max_prime_index, i)

        return max_prime_index - min_prime_index

class Solution:
    def maximumPrimeDifference(self, nums: List[int]) ->int:
        ans = 0
        lastp = -1
        for x in nums:
            if self.isprime(x):
                if lastp != -1:
                    ans = max(ans, x - lastp)
                lastp = x
        return ans

    def isprime(self, x: int) ->bool:
        if x < 2:
            return False
        for i in range(2, int(x ** 0.5) + 1):
            if x % i == 0:
                return False
        return True

def process_func(example):
    MAX_LENGTH = 384   
    input_ids, attention_mask, labels = [], [], []
    instruction = tokenizer(f"<|im_start|>system\n现在你要扮演皇帝身边的女人--甄嬛<|im_end|>\n<|im_start|>user\n{example['instruction'] + example['input']}<|im_end|>\n<|im_start|>assistant\n", add_special_tokens=False)  
    response = tokenizer(f"{example['output']}", add_special_tokens=False)
    input_ids = instruction["input_ids"] + response["input_ids"] + [tokenizer.pad_token_id]
    attention_mask = instruction["attention_mask"] + response["attention_mask"] + [1]  
    labels = [-100] * len(instruction["input_ids"]) + response["input_ids"] + [tokenizer.pad_token_id]  
    if len(input_ids) > MAX_LENGTH:  
        input_ids = input_ids[:MAX_LENGTH]
        attention_mask = attention_mask[:MAX_LENGTH]
        labels = labels[:MAX_LENGTH]
    return {
        "input_ids": input_ids,
        "attention_mask": attention_mask,
        "labels": labels
    }

有一个很古老的村子，这个村子的人分两种，红眼睛和蓝眼睛，这两种人并没有什么不同，小孩在没生出来之前，没人知道他是什么颜色的眼睛，这个村子中间有一个广场，是村民们聚集的地方，现在这个村子只有三个人，分住三处。在这个村子，有一个规定，就是如果一个人能知道自己眼睛的颜色并且在晚上自杀的话，他就会升入天堂，这三个人不能够用语言告诉对方眼睛的颜色，也不能用任何方式提示对方的眼睛是什么颜色，而且也不能用镜子、水等一切有反光的物质来看到自己眼睛的颜色，当然，他们不是瞎子，他们能看到对方的眼睛，但就是不能告诉他！他们只能用思想来思考，于是他们每天就一大早来到广场上，面对面的傻坐着，想自己眼睛的颜色，一天天过去了，一点进展也没有。直到有一天，来了一个外地人，他到广场上说了一句话，改变了他们的命运，他说，你们之中至少有一个人的眼睛是红色的。说完就走了。这三个人听了之后，又面对面的坐到晚上才回去睡觉，第二天，他们又来到广场，又坐了一天。当天晚上，就有两个人成功的自杀了！第三天，当最后一个人来到广场，看到那两个人没来，知道他们成功的自杀了，于是他也回去，当天晚上，也成功的自杀了！根据以上，请说出三个人的眼睛的颜色，并能够说出推理过程！