O Technology Innovation Institute lançou recentemente o modelo de linguagem grande (LLM) Falcon 180B, que supera o Llama-2 70b e está no mesmo nível do modelo básico PaLM-2 Large do Google Bard.
O 180B é a versão mais recente do modelo Falcon 40B. Aqui está uma rápida visão geral do modelo:
Modelo de parâmetros 180B, duas versões (base e chat)
Treine com 3,5 trilhões de tokens usando o conjunto de dados RefinedWeb
O contexto tem no máximo 2.048 tokens
É aproximadamente do tamanho do ChatGPT (GPT-3.5), que possui parâmetros de 175B. É o melhor?Em setembro de 2023, o Falcon 180B era o número um no ranking de modelos da Hug Face.
Variantes de modelo
O Falcon 180B vem em duas versões – básica e chat.
A versão básica é um modelo de decodificador causal. Este modelo é ótimo para ajustes adicionais em seus próprios dados.
A versão chat é semelhante à versão básica, que também é um modelo de decodificador causal com 180 bilhões de parâmetros. Mas é ajustado nos conjuntos de dados de comando (chat) Ultrachat5, Platypus6 e Airboros7.
Desempenho do modelo
Em termos de capacidades, o Falcon 180B está lado a lado com o PaLM-2 Large, tornando-o um dos modelos de linguagem mais poderosos disponíveis ao público.
O modelo Falcon quantificado manteve métricas semelhantes em todos os benchmarks.
Analisando as classificações do Open LLM, você notará que, apesar das afirmações de que é o melhor Open LLM, a versão ajustada do Llama 2 ainda é melhor que o Falcon 180B. Mas é importante notar que o modelo original do Llama 2 veio após o lançamento do Falcon.
Requisitos de hardware
Embora o uso do modelo seja gratuito, você terá dificuldade em executá-lo em uma GPU normal. Mesmo a versão GPTQ (The Bloke) deste modelo ainda requer mais de 80 GB de VRAM. Dê uma olhada nesta tabela da postagem de HF:
8 GPUs A100 de 80 GB – novamente após quantização com meia precisão (FP16). A seleção da precisão int4 ainda requer 320 GB de memória.
Então, quanto custam 8 A100s? A seguir está o preço por hora da GPU A100 para AWS no Leste dos EUA.
Em outras palavras, se você executar int4, será cerca de US$ 24.000 por mês e, com meia precisão, será cerca de US$ 30.000.
O papel dos conjuntos de dados
A Lei de Escalabilidade de Chinchilla afirma que o tamanho de um modelo e seu conjunto de dados de treinamento devem crescer simultaneamente para maximizar o desempenho dentro de um determinado orçamento computacional.
Falcon180B foi treinado em impressionantes 3,5 trilhões de tokens usando o conjunto de dados RefinedWeb. O RefinedWeb não é apenas enorme, mas também cuidadosamente refinado, aprimorado e treinado com algum conteúdo adicional cuidadosamente selecionado. E a TII continua a enfatizar a importância do RefinedWeb na criação de seu modelo Falcon.
As implicações práticas deste princípio em aplicações práticas são muito profundas, este efeito pode ser visto quando o modelo Llama-65B é treinado em 1,4 trilhão de tokens e tem um desempenho significativamente melhor do que o modelo OPT-175B porque este último foi treinado em apenas 180 bilhões fichas. Isto também ilustra plenamente que quando os modelos grandes carecem de dados suficientes, o seu desempenho pode ser superado por modelos pequenos com dados ricos.
Falcon 180b vs ChatGPT
O Falcon 180B pode ser testado através da demonstração no HuggingFace. As demonstrações são limitadas a uma sessão de aproximadamente 1.000 palavras.
Compararemos o desempenho do ChatGPT e do Falcon 180B no mesmo prompt. A seguir está a configuração padrão do Falcon 180B Demo:
Temperatura: 0
Máximo de novos tokens: 512
P superior: 0,9
Penalidade de repetição: 1.1
Vamos testar o desempenho dele
Qual é a última data que você conhece?
**Falcon 180B**:
As an AI language model, I do not have knowledge of specific dates unless they
are provided to me. Please provide a specific date or context for me to answer
your question accurately.
**ChatGPT**:
My knowledge is current up to September 2021. I do not have information on
events, developments, or information that has occurred after that date. If you have
questions or need information beyond that date, I may not be able to provide it. Please
verify any information I provide with more up-to-date sources.
Ou seja, os dados de uso não foram indicados durante o treinamento, mas segundo dicas oficiais, já deve ser a vez do RefinedWeb.
geração de código
A geração de código é algo que nos preocupa mais, mas os modelos menores (7B-40B) não funcionam bem com códigos, então surgiu o Code Llama dedicado .
Escreva uma função em python que calcule o quadrado da soma de dois números.
Falcão 180B:
Here is a simple function in Python that calculates the square of a sum of two
numbers:
```py
def square_sum(num1, num2):
return (num1 + num2)**2
Esta função recebe dois argumentos num1 e num2, soma-os e depois
calcula o quadrado do resultado usando o operador de exponenciação (**).
O resultado final é retornado.
Por exemplo, se você chamar square_sum(3, 4), ele retornará 49, porque (3 + 4)
2 = 7 2 = 49.
**ChatGPT**:
Você pode criar uma função Python para calcular o quadrado da soma de dois
números como este:
def square_of_sum(num1, num2):
# Calculate the sum of the two numbers
total = num1 + num2
# Calculate the square of the sum
square = total ** 2
return square
# Example usage:
num1 = 5
num2 = 3
result = square_of_sum(num1, num2)
print(f"The square of the sum of {
num1} and {
num2} is {
result}")
Esta função square_of_sumrecebe dois números como entrada, calcula sua
soma e depois calcula o quadrado dessa soma. O resultado é retornado pela
função. Você pode chamar esta função com valores diferentes de num1e num2
para calcular o quadrado da soma de dois números quaisquer.
虽然ChatGPT的代码多，但是180B的代码更简洁，更容易阅读。让我们试一个更难的:
> Write a function in python that splits a list into 3 equal parts and returns alist with a random element of each sublist.
**Falcon 180B**:
Aqui está uma função que faz o que você está pedindo:
import random
def split_list(lst):
n = len(lst)
part_size = n // 3
parts = [lst[i:i+part_size] for i in range(0, n, part_size)]
return [random.choice(part) for part in parts]
Esta função pega uma lista lst como entrada e a divide em três partes iguais
usando o fatiamento da lista. Em seguida, ele seleciona um elemento aleatório de cada sublista usando
a função random.choice() e retorna uma nova lista contendo esses elementos.
Aqui está um exemplo de uso da função:
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lista_dividida(lst)
[5, 6, 7]
Neste exemplo, a lista de entrada lst é dividida em três partes iguais de tamanho 3
e um elemento aleatório é selecionado de cada parte para formar a lista de saída [5, 6, 7].
**ChatGPT**:
Você pode conseguir isso primeiro dividindo a lista em três partes iguais e
depois selecionando um elemento aleatório de cada sublista. Aqui está uma função Python para
fazer isso:
import random
def split_and_random_elements(input_list):
# Calculate the size of each sublist
sublist_size = len(input_list) // 3
# Split the input list into three sublists
sublists = [input_list[i:i + sublist_size] for i in range(0, len(input_list), sublist_size)]
# Initialize a list to store the random elements
random_elements = []
# Select a random element from each sublist
for sublist in sublists:
if sublist:
random_element = random.choice(sublist)
random_elements.append(random_element)
return random_elements
# Example usage:
input_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = split_and_random_elements(input_list)
print(result)
Nesta função, primeiro calculamos o tamanho de cada sublista dividindo o
comprimento da lista de entrada por 3. Em seguida, usamos a compreensão da lista para dividir a
lista de entrada em três sublistas de tamanho igual. Finalmente, iteramos pelas
sublistas e usamos a random.choicefunção para selecionar um elemento aleatório de
cada sublista e anexá-lo à random_elementslista, que é retornada como
resultado.
Falcon 180B的代码更简洁，但是它的代码有一个错误输出的例子。这样看对于代码生成而言，还有很大的微调空间。
**QA**
我们用下面这个表提问
Use os dados da tabela de descontos:
|Model|Size|Code|Commonsense Reasoning|World Knowledge|Reading Comprehension|Math|MMLU|BBH|AGI Eval|
| — -| — -| — -| — -| — -| — -| — -| — -| — -| — -|
|Llama 1|7B|14.1|60.8|46.2|58.5|6.95|35.1|30.3|23.9|
|Llama 1|13B|18.9|66.1|52.6|62.3|10.9|46.9|37.0|33.9|
|Llama 1|33B|26.0|70.0|58.4|67.6|21.4|57.8|39.8|41.7|
|Llama 1|65B|30.7|70.7|60.5|68.6|30.8|63.4|43.5|47.6|
|Llama 2|7B|16.8|63.9|48.9|61.3|14.6|45.3|32.6|29.3|
|Llama 2|13B|24.5|66.9|55.4|65.8|28.7|54.8|39.4|39.1|
|Llama 2|70B|**37.5**|**71.9**|**63.6**|**69.4**|**35.2**|**68.9**|**51.2**|**54.2**|
para responder à pergunta:
Calcule quão melhor (% de aumento) é Llama 2 7B vs Llama 1 7B em compreensão de leitura?
回答结果如下：
**Falcon 180B**:
A pontuação de compreensão de leitura para Llama 1 7B é 58,5 e para Llama 2 7B é
61,3. Para calcular o aumento percentual, usamos a fórmula:
Aumento percentual = ((Novo valor - Valor antigo) / Valor antigo) * 100
Conectando os valores, obtemos:
Aumento percentual = ((61,3 - 58,5) / 58,5) * 100 = 5,1%
Portanto, o Llama 2 7B é 5,1% melhor que o Llama 1 7B em compreensão de leitura.
**ChatGPT**:
Para calcular o aumento percentual na compreensão de leitura entre Llama 2
7B e Llama 1 7B, você pode usar a seguinte fórmula:
Aumento percentual = [(Novo valor - Valor antigo) / Valor antigo] * 100
Nesse caso:
- Novo valor (compreensão de leitura do Llama 2 7B): 61,3
- Valor antigo (compreensão de leitura do Llama 1 7B): 58,5
Agora, insira esses valores na fórmula:
Aumento percentual = [(61,3 - 58,5) / 58,5] * 100
Aumento percentual = [(2,8) / 58,5] * 100
Aumento percentual ≈ 4,79%
Portanto, o Llama 2 7B tem um desempenho aproximadamente 4,79% melhor do que o Llama 1 7B em
compreensão de leitura.
两种模型给出了不同的答案。哪一个是正确的?好吧，ChatGPT对了：
Percentage Increase = ((61.3–58.5) / 58.5) * 100 = 5.1%
Falcon 180B的公式是没问题的，但是最后一步的除法算错了。
## 总结
Falcon 180B是目前最大的公开模特。它在排行榜上名列前茅，甚至给那些大牌的专有模式，比如PaLM-2，带来了竞争压力。但是我们的评估表明，它可能还需要有更大的提升。
对于有兴趣测试和评估LLM的个人或组织，有以下建议:
1、定义明确的目标:了解想通过评估达到什么目标。无论是衡量模型在语言理解方面的熟练程度，探索道德考虑，还是测试偏见，有一个明确的目标将指导评估过程。
2、多样化的输入:确保测试数据集包含广泛的主题、语言、文化和复杂性。这确保了对模型能力的全面评估。
3、检查偏差:在模型的反应中积极寻找明显和微妙的偏差。这包括与种族、性别、国籍等有关的偏见。LLM可能会无意中携带训练数据中存在的偏见。
4、复杂场景:不仅给模型提供简单的问题，还要提供复杂的、多方面的场景，以了解其深度和推理能力。
5、一致性:以不同的时间间隔多次运行相同或类似的查询，检查响应的一致性。
6、真实世界用例:在业务领域相关的实际的、真实的场景中测试模型。这给了一个概念，如何很好地将模型集成到实际应用中。
7、与替代方案比较:如果可能，将输出与其他类似的llm进行比较。这将给出一个相对的性能度量。
8、反馈循环:实现一个反馈机制，在这个机制中，评估者可以对模型的响应提供反馈。这对于迭代改进是有价值的。
9、了解局限性:每个模型都有其局限性。注意模型的知识边界、任何预先设定的边界以及它的一般设计约束。
10、安全措施:特别是在面向公众的应用程序中使用该模型时，要实现保护措施以防止有害输出或误用。
11、保持更新:LLM不断发展。随时了解模型的最新版本和改进。
相信随着LLM不断发展，他会与我们的日常生活更加无缝地融合在一起，但是现在还为时过早，而且我个人认为，在硬件限制的情况下，减小模型的大小这个研究方向是非常有前途的，包括，模型压缩，发现更小但是更好的模型，甚至是另外一种更高效的建模方法。
[https://avoid.overfit.cn/post/14268c27f72a4c9d994e9acfbcae25b0](https://avoid.overfit.cn/post/14268c27f72a4c9d994e9acfbcae25b0)