PS à frente da AD nas europeias

[MarcoAntonio]

Se tiveres {()()} é invalido. (num IDE algo assim devia ser valido, mas não foi o que lhe pedi).

No teu enunciado isso não está especificado e diz apenas "contains" (o que é verdade para este exemplo que acabaste de dar).





Aliás, no código que ele está a implementar se calhar para essa string vai retornar True também (mas não estou a ver o código completo e quanto a isso, a esta hora da noite, já não digo nada). Do que se vê, o comportamento da stack deverá ser este:

{ -> {
( -> {(
) -> {
( -> {(
) -> {
} -> _

(à esquerda o caracter iterado no ciclo for; à direita o resultado na stack em cada iteração; e o _ no fim significa que a stack fica vazia)

[MarcoAntonio]

Estou a ver uma unidade central da empresa que substitui a parafernália de sistemas que existem actualmente. Tipo um mainfraime omnipotente.

Os ChatGTPs são os IDE do futuro. Uma rede treinada com agentes em todo o SW de uma empresa imagino que pode ser autossustentável. Capaz de manter e criar bases de dados ou interfaces para o utilizador.

Para programadores/developers, já existe isto inclusivamente:

https://github.com/features/copilot

[BearManBull]

O código está bem (por acaso é mais ou menos assim que os IDE validam se os parênteses fecham todos corretamente).

Se tiveres {()()} é invalido. (num IDE algo assim devia ser valido, mas não foi o que lhe pedi).
({()}] é invalido.
({()}) é válido.
{{[[(())]]}} é válido.

O que queria validar era se usava a Stack para resolver o problema em vez de usar ciclos for.

[MarcoAntonio]

Ele está a considerar que o input é exactamente o que colocaste no fim (o que dá para customizar com um input do user, por exemplo). Fazia mais sentido ele (apenas) escrever o código em que a string de input passava como argumento no método.

O enunciado não especifica (e o código não se vê completo) mas parece que o que ele está a testar realmente é se a string só tem matched sets (podia ser essa a intenção ou não). Mas "contain" (conter) não implica que não contém nada mais além disso.

O codigo parece estar a implementar na base de "consists of".

[BearManBull]

Um dia destes não se instalam mais IDEs....

Estou a ver uma unidade central da empresa que substitui a parafernália de sistemas que existem actualmente. Tipo um mainfraime omnipotente.

Os ChatGTPs são os IDE do futuro. Uma rede treinada com agentes em todo o SW de uma empresa imagino que pode ser autossustentável. Capaz de manter e criar bases de dados ou interfaces para o utilizador.

[BearManBull]

Um exemplo em que recorre a um estrutura de dados mais indicada para resolver o problema.

Mais incrível que processa tudo, mesmo com erros ortográficos e gramaticais.

[MarcoAntonio]

Com algum trabalho, é possível po-lo a executar código (se pedires directamente, ele tende a recusar). Mas é possível.





Um dia destes não se instalam mais IDEs....

[BearManBull]

Mesmo assim é assombroso, consegue mesmo fazer programação dinâmica.

E deixa a explicação por baixo, só para deixar claro que não foi ao acaso.

[MarcoAntonio]

Em código, ele tende a ser bastante bom (melhor que em operações matemáticas, por exemplo). Está algures referido que uma parte do dataset é documentação de código e código propriamente dito. Linguagens que ele domina bem e é capaz de produzir código funcional ou quase incluem C, Java, Matlab, Python (a principal linguagem utilizada para o criar), SQL, etc.


Nota: o GPT-2 está disponível no github e encontra-se escrito em Python.

[BearManBull]

Bem fiz uns testes para ver se a maquina sabe programar o resultado é deveras impressionante.

[MarcoAntonio]

Aqui fica um artigo sobre um campo de aplicação diferente (CV, computer vision) e que envolve treinar redes que aprendem a classificar qualitativamente imagens com base em classificações subjectivas dadas por labelers humanos (para dessa forma superar o que é possível com métricas objectivas e/ou atingir resultados que são melhores do ponto de vista dos humanos):

Deep Image Quality Assessment

In rating participants are asked to assign a single score to the image from a pre-defined scale. Rating results depend on the selection of images for the experiment and training procedure. At the same time, ranking is much simpler as it asks a simple question — which image is better. A big drawback of ranking is a large number of possible comparisons. I have also had a chance to work with methods of efficient pair selection for ranking experiments and discussed the general pipeline in this article.

Poderás achar que uma coisa é classificar textos e outra classificar imagens, mas na verdade é fundamentalmente a mesma coisa. Os labelers vão tentar seguir as indicações dadas pelos developers mas vão classificar as imagens (ou os textos) de uma forma que é inerentemente subjectiva e que resulta da sua própria percepção individual. O método de recorrer a pools de sujeitos de teste que apreciam diferentes resultados extravasa o Machine Learning e é utilizado também noutras áreas como o processamento e/ou compressão de imagem ou som, nomeadamente; uma métrica ou standard amplamente utilizada dá pelo nome de Mean Opinion Score (MOS). Hoje em dia estas técnicas já não se usam só para tentar determinar qual é o melhor algoritmo para uma determinada tarefa mas inclusivamente para treinar redes neuronais que são capazes de "imitar" (ou substituir) os humanos nesse processo.

[MarcoAntonio]

Ninguem disse o contrario mas não deixa de ser engenhoso para caracterizar algo tao subjectivo como é a qualidade de um chat.

Sim, mas isto é bastante mais normal do que me parece que estás a supor. Os modelos em diversas áreas são sistematicamente avaliados com métricas subjectivas e metricas objectivas (basicamento tudo o que tenha que ver com percepção, em última instância o que interessa mesmo nem são as métricas objectivas mas sim as subjectivas). Incluindo treinar modelos para classificar ou treinar outros modelos.

Quanto ao CdB estar ou não incorporado, de momento pode não estar, suponho que a seu tempo irá eventualmente estar. É a expectativa que tenho, uma IAG vai incorporar os pensamentos de toda a gente. E não vamos ter ilusões, o objectivo, que também se refere no video, é que se consiga gerar uma IAG é para isto que se tenta caminhar.

Isto é motivo de grande debate. A ideia/objectivo de longo-prazo é criar uma inteligência artificial geral. Mas se é meramente uma questão de escala ou não ou se falta ainda algum elemento que ainda nem sequer identificamos, isso na realidade não se sabe.

O que me parece evidente é que em relativamente pouco tempo vai começar a ser difícil distinguir se já chegamos lá ou não (isto remete também para os temas do turing test, chinese room e afins e são motivo de aceso debate).

[BearManBull]

Fiz referencia por ser curioso realmente como ele refere o problema. Ao certo é muito difícil sequer definir o que é um chat dar uma resposta adequada.

O exemplo que poem num jogo é fácil, quanto maior o score melhor portanto é fácil dar essa baliza à rede a ser treinada.

No caso de um chat, o que raios é um chat que dá respostas adequadas? Pois parece que é aquilo que um grupo de pessoas identifica como adequado. E foi este conceito que foi incorporado no RM reward model que mencionaste.

O Reinforcement Learning é apenas a última fase do treino (por esta altura o modelo já está largamente treinado)

Ninguem disse o contrario mas não deixa de ser engenhoso para caracterizar algo tao subjectivo como é a qualidade de um chat.

Uma coisa é ter um robot que dá saltos outra é um que dá um mortal e aterra com braços estendidos. No vídeo faz uma referencia desse estilo.


Quanto ao CdB estar ou não incorporado, de momento pode não estar, suponho que a seu tempo irá eventualmente estar. É a expectativa que tenho, uma IAG vai incorporar os pensamentos de toda a gente. E não vamos ter ilusões, o objectivo, que também se refere no video, é que se consiga gerar uma IAG é para isto que se tenta caminhar.

[MarcoAntonio]

Acho que vale a pena deixar este exemplo também porque de certa forma permite visualizar o RM já em funcionamento. O que esta tabela apresenta é o diferencial do reward atribuido pelo RM que ocorre quando um humano altera (edita) uma resposta.




(para que não haja confusão, este segundo quadro não diz respeito ao treino mas à validação)

[MarcoAntonio]

Deixo aqui as instruções dadas aos labelers no caso do instructGPT (extraído do paper que já partilhei antes) para uma tarefa específica que consistia em resumir posts do reddit. As do ChatGPT poderão não ter sido exactamente iguais, mas será algo dentro disto e serve para ilustrar o que resumi atrás (ie, o ranking das respostas seguirá parâmetros deste tipo).

[MarcoAntonio]

Fiz referencia por ser curioso realmente como ele refere o problema. Ao certo é muito difícil sequer definir o que é um chat dar uma resposta adequada.

O exemplo que poem num jogo é fácil, quanto maior o score melhor portanto é fácil dar essa baliza à rede a ser treinada.

No caso de um chat, o que raios é um chat que dá respostas adequadas? Pois parece que é aquilo que um grupo de pessoas identifica como adequado. E foi este conceito que foi incorporado no RM reward model que mencionaste.

O Reinforcement Learning é apenas a última fase do treino (por esta altura o modelo já está largamente treinado) e dedica-se essencialmente a lidar com um problema que neste campo (LLM) se denomina de misalignment. No caso do ChatGPT eles geraram salvo erro entre 4 a 10 respostas por prompt. O objectivo dos "labelers" é classificar via ranking das melhores para as piores segundo uma série de parametros. Podem envolver diversos critérios relativos à qualidade da resposta (se é concisa ou não, se está dentro do contexto pretendido ou se ele respondeu com algo que não era o pretendido e por aí fora). Julgo que um dos papers refere que eles disponibilizam este dataset, mas não verifiquei.

Isto é, em si, já uma fase de fine-tuning e diferentes modelos provavelmente vão ter diferentes características em virtude disso (a malta alega que o do bing tem uma personalidade diferente da do ChatGPT, mas pessoalmente não experimentei, estou em lista de espera).

Também outra nota curiosa sobre o ChatGTP, como come informação de toda a internet, acaba por incorporar muito do que se escreve pela web e obviamente o que vai no CdB, no final exitem ali uns pesos que foram de certa forma afectado com o conteúdo produzido no CdB. Ou seja estas máquinas são aquilo que tivemos mais próximo de uma inteligencia colectiva com rasgos gerados um pouco por toda a humanidade.

Bom, não come toda a informação mas só o que estiver no dataset (duvido que o CdB estivesse no dataset, como é composto os datasets que têm sido utilizados é mais ou menos conhecido). Entretanto, o Bard e outros vão passar a ter acesso à internet durante a inferência (mas como já discutimos atrás, isso é diferente do treino).

[BearManBull]

Isto que referes diz respeito ao último passo e que consistiu em colocar o modelo pré-treinado a gerar uma série de respostas possíveis para cada prompt para ser classificado por humanos (via um ranking, da melhor para a pior resposta). Isto permitiu criar um novo dataset de tamanho bastante razoável, o qual foi usado para treinar vários modelos (RM, reward model, eles próprios redes neuronais) utilizados durante o reinforcement learning.

Fiz referencia por ser curioso realmente como ele refere o problema. Ao certo é muito difícil sequer definir o que é um chat dar uma resposta adequada.

O exemplo que poem num jogo é fácil, quanto maior o score melhor portanto é fácil dar essa baliza à rede a ser treinada.

No caso de um chat, o que raios é um chat que dá respostas adequadas? Pois parece que é aquilo que um grupo de pessoas identifica como adequado. E foi este conceito que foi incorporado no RM reward model que mencionaste.

É uma solução realmente engenhosa, a forma como se contornam problemas que se fossem abordados numa vertente clássica de algoritmo eram problemas que muito dificilmente tinham solução. Pior é que nem sabe ao certo como os formular. Mas de resto isto acontece um pouco em tudo que é AI como é o simples reconhecimento de carácteres. Para mim é fascinante, até mesmo o facto de a natureza (as leis da física do universo) permitirem que mecanismos deste tipo sejam possíveis. Isto é de certa forma análogo a um wormhole que permite contornar limitações físicas como o viajar à velocidade luz.

Também outra nota curiosa sobre o ChatGTP, como come informação de toda a internet, acaba por incorporar muito do que se escreve pela web e obviamente o que vai no CdB, no final exitem ali uns pesos que foram de certa forma afectado com o conteúdo produzido no CdB. Ou seja estas máquinas são aquilo que tivemos mais próximo de uma inteligencia colectiva com rasgos gerados um pouco por toda a humanidade.

[MarcoAntonio]

Aqui um paper sobre as capacidades emergentes de modelos deste tipo (o paper é de Agosto do ano passado, ainda antes da disponibilização pública do ChatGPT). Os autores são investigadores da Google, de Stanford, da DeepMind (uma "concorrente" da OpenAI), etc.

Emergent Abilities of Large Language Models

Abstract

Scaling up language models has been shown to predictably improve performance and sample
efficiency on a wide range of downstream tasks. This paper instead discusses an unpredictable
phenomenon that we refer to as emergent abilities of large language models. We consider an
ability to be emergent if it is not present in smaller models but is present in larger models.
Thus, emergent abilities cannot be predicted simply by extrapolating the performance of
smaller models. The existence of such emergence raises the question of whether additional
scaling could potentially further expand the range of capabilities of language models.

O paper discute também como são avaliados os modelos (model evaluation) incluindo a descrição de tasks específicas, para quem estiver mais interessado em perceber o que está por detrás destes modelos.

[MarcoAntonio]

A título de curiosidade, isto de usar redes neuronais para treinar outras redes neuronais não é propriamente estranho também e é utilizado em várias técnicas e arquitecturas. Teacher-student networks e Generative Adversarial Networks (GAN), para citar dois exemplos. No primeiro caso, treina-se uma rede primeiro e depois a outra com a ajuda da primeira (já pré-treinada); já no segundo caso, o treino das várias sub-redes dá-se em simultaneo (mas em que umas aprendem à custa das outras).

[MarcoAntonio]

Partilho três videos que falam especificamente do ChatGTP e da tecnologia Transformers que curiosamente parece já existir á algum tempo.

O paper original ('Attention is all you need') está mais atrás no tópico e é de 2017 (o mecanismo de atenção é anterior, mas o paper original em que se propõe uma rede neuronal montada com base só neste mecanismo surge nesse paper). Deixo aqui de novo, já agora.

Ao que parece o GTP foi treinado por uma AI que replica comportamento humano, para dar o feedback necessário ao engine enquanto está a em modo treino.

Do que se sabe, o ChatGPT foi treinado via treino não supervisionado (pré-treino), seguido de treino supervisionado para algumas tarefas específicas (estão ambas explicadas num paper que já partilhei aqui também) - até aqui temos o modelo pré-treinado GPT - e finalmente via reinforcement learning from human feedback. A openAI expõe o que fez em dois papers, um já está aqui no tópico e o outro é relativo ao instructGPT (disponível aqui). Isto que referes diz respeito ao último passo e que consistiu em colocar o modelo pré-treinado a gerar uma série de respostas possíveis para cada prompt para ser classificado por humanos (via um ranking, da melhor para a pior resposta). Isto permitiu criar um novo dataset de tamanho bastante razoável, o qual foi usado para treinar vários modelos (RM, reward model, eles próprios redes neuronais) utilizados durante o reinforcement learning.

Há mais passos envolvidos, mas os modelos RM basicamente aprendem a prever a classificação dada por humanos a partir daquele dataset.

[BearManBull]

Um dos canais que sigo no youtube, se quiserem ouvir especialistas de topo falar sobre AI e no canal têm outras telemáticas relacionadas com TI/teoria de informação/etc...

Partilho três videos que falam especificamente do ChatGTP e da tecnologia Transformers que curiosamente parece já existir há algum tempo.


Ao que parece o GTP foi treinado por uma AI que replica comportamento humano, para dar o feedback necessário ao engine enquanto está a em modo treino.

[MarcoAntonio]

Step 2

Ok, vamos agora ao código.




O que ele me forneceu para a rede e para o training loop:

Código: Selecionar todos

import torch
import torch.nn as nn

# Define hyperparameters
NUM_LAYERS = 2
NUM_HEADS = 8
D_MODEL = 512
D_FF = 2048
DROP_RATE = 0.1
VOCAB_SIZE = 10000

# Define the encoder layer
class EncoderLayer(nn.Module):
    def __init__(self):
        super(EncoderLayer, self).__init__()
        self.self_attn = nn.MultiheadAttention(D_MODEL, NUM_HEADS, DROP_RATE)
        self.feed_forward = nn.Sequential(
            nn.Linear(D_MODEL, D_FF),
            nn.ReLU(),
            nn.Dropout(DROP_RATE),
            nn.Linear(D_FF, D_MODEL),
            nn.Dropout(DROP_RATE),
        )
        self.layer_norm1 = nn.LayerNorm(D_MODEL)
        self.layer_norm2 = nn.LayerNorm(D_MODEL)
   
    def forward(self, x):
        x_norm = self.layer_norm1(x)
        attn_output, _ = self.self_attn(x_norm, x_norm, x_norm)
        x = x + attn_output
        x_norm = self.layer_norm2(x)
        feed_forward_output = self.feed_forward(x_norm)
        x = x + feed_forward_output
        return x

# Define the encoder
class Encoder(nn.Module):
    def __init__(self):
        super(Encoder, self).__init__()
        self.embedding = nn.Embedding(VOCAB_SIZE, D_MODEL)
        self.pos_embedding = nn.Embedding(1000, D_MODEL)
        self.layers = nn.ModuleList([EncoderLayer() for _ in range(NUM_LAYERS)])
        self.dropout = nn.Dropout(DROP_RATE)
   
    def forward(self, x):
        x = self.embedding(x)
        seq_len = x.size(1)
        pos = torch.arange(seq_len, device=x.device).unsqueeze(0).repeat(x.size(0), 1)
        pos = self.pos_embedding(pos)
        x = x + pos
        x = self.dropout(x)
        for layer in self.layers:
            x = layer(x)
        return x

# Define the decoder layer
class DecoderLayer(nn.Module):
    def __init__(self):
        super(DecoderLayer, self).__init__()
        self.self_attn = nn.MultiheadAttention(D_MODEL, NUM_HEADS, DROP_RATE)
        self.encoder_attn = nn.MultiheadAttention(D_MODEL, NUM_HEADS, DROP_RATE)
        self.feed_forward = nn.Sequential(
            nn.Linear(D_MODEL, D_FF),
            nn.ReLU(),
            nn.Dropout(DROP_RATE),
            nn.Linear(D_FF, D_MODEL),
            nn.Dropout(DROP_RATE),
        )
        self.layer_norm1 = nn.LayerNorm(D_MODEL)
        self.layer_norm2 = nn.LayerNorm(D_MODEL)
        self.layer_norm3 = nn.LayerNorm(D_MODEL)
   
    def forward(self, x, encoder_output):
        x_norm = self.layer_norm1(x)
        self_attn_output, _ = self.self_attn(x_norm, x_norm, x_norm)
        x = x + self_attn_output


(...)

Código: Selecionar todos

# Define the output layer
class OutputLayer(nn.Module):
    def __init__(self):
        super(OutputLayer, self).__init__()
        self.linear = nn.Linear(D_MODEL, VOCAB_SIZE)
   
    def forward(self, x):
        return self.linear(x)

# Define the full model
class TransformerChatbot(nn.Module):
    def __init__(self):
        super(TransformerChatbot, self).__init__()
        self.encoder = Encoder()
        self.decoder = Decoder()
        self.output_layer = OutputLayer()
   
    def forward(self, input_seq, target_seq):
        encoder_output = self.encoder(input_seq)
        decoder_output = self.decoder(target_seq, encoder_output)
        output = self.output_layer(decoder_output)
        return output

# Define the loss function
loss_fn = nn.CrossEntropyLoss()

# Define the optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)

# Define the training loop
def train(model, dataloader, loss_fn, optimizer, device):
    model.train()
    total_loss = 0
    total_tokens = 0
    for input_seq, target_seq in dataloader:
        input_seq = input_seq.to(device)
        target_seq = target_seq.to(device)
        optimizer.zero_grad()
        output = model(input_seq, target_seq[:,:-1])
        loss = loss_fn(output.reshape(-1, VOCAB_SIZE), target_seq[:,1:].reshape(-1))
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * target_seq.size(0)
        total_tokens += target_seq.size(0) * target_seq.size(1)
    return total_loss / total_tokens


[MarcoAntonio]

Amanhã peço-lhe para gerar o código necessário para criar um clone do ChatGPT.

Step 1



Nada mau, para começar...

[BearManBull]

pedir a uma rede neuronal para criar uma rede neuronal.

Auto replicante, ainda vai acabar a gerar um Gray goo virtual


Muito interessante esse teste

[BearManBull]

Moral da história: sim, o ChatGPT comete erros e tem limitações. Mas quem ainda julga que isto é praticamente o mesmo que um motor de busca, não está a ver bem o filme.

Ainda nem tinha explorado nada equações e formulas matemáticas

O exemplo que dei do ensino básico foi apenas para formular o quão revolucionária é a ferramenta. Id est, a ficar-se só pelo ensino básico já era de si algo que nunca foi alcançado.