OE aprovado na generalidade, Montenegro insiste no "sentido de responsabilidade" na especialidade

[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.

[MarcoAntonio]

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

[MarcoAntonio]

Now for something different: pedir a uma rede neuronal para criar uma rede neuronal.

Using Pytorch and the MNIST dataset, write code to model a neural network able to classify handwritten digits. Consider the neural network as having the input layer, two hidden layers and a softmax output layer.

Código: Selecionar todos

import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.optim as optim

# Define the transform to normalize the data
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# Load the MNIST dataset
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

# Define the neural network architecture
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 28*28)
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = nn.functional.softmax(self.fc3(x), dim=1)
        return x

net = Net()

# Define the loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

# Train the neural network
for epoch in range(10):  # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

print('Finished Training')


Está perfeitamente funcional, só tive de acrescentar uma linha para gravar o modelo. E como não quero ter trabalho, pedi-lhe para escrever o código para testar a rede acabada de treinar:

Assuming that I saved the network trained with the previous code as "my_model.pt", write the code to test the trained network.

O código tem dois pequenos problemas para conseguir correr autonomamente e sem erros (falta definir a class net outra vez - basta um copy-paste - e é preciso um pequeno ajuste a carregar a rede, fora isso está tudo bem).

Código: Selecionar todos

import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn

# Define the transform to normalize the data
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# Load the MNIST test dataset
testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

# Load the trained network
net = Net()
net.load_state_dict(torch.load('my_model.pt'))

# Test the network on the test dataset
net.eval()
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))


Resultado (via Anaconda):

[MarcoAntonio]

Outro exemplo. Só funcionou correctamente à segunda. Da primeira vez, removeu o verde "depois" da conversão, o que obviamente iria gerar um erro... aparentemente foi causado por eu ter só adicionado no fim que era para remover o canal do verde na conversão; quando reformulei o pedido, fez tudo correcto (não é que o original estivesse mal formulado, entenda-se).





Demonstração do código (que está perfeitamente funcional e faz o que se pede).



Para bem, para bem, ele deveria ter adicionado uma terceira imagem sem o canal verde e coloca-la ali no meio das outras duas. Mas ele já produziu a demonstração, com legendas e tudo, sem eu ter pedido sequer...





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.

[MarcoAntonio]

Ele consegue fazer mais do que TPC's do ensino básico. Claro que às vezes também se espalha.


Aqui, espalhou-se. Mas anda lá perto...




Já aqui, acertou em cheio.

[BearManBull]

ChatGPT: "Motoristas, maquinistas ou programadores básicos. Muito destes empregos vão desaparecer num futuro próximo"

O presidente da Associação Portuguesa para a Inteligência Artificial disse hoje que ferramentas como a ChatGPT permitem acelerar tarefas laborais e aumentar a produtividade, mas vão levar ao desaparecimento de profissões como motoristas, maquinistas ou programadores.

Em entrevista à agência Lusa, à margem dum seminário sobre “Inteligência Artificial e o ChatGPT - Disrupção Pedagógica no Ensino”, que decorreu hoje, no Porto, o presidente da presidente da Associação Portuguesa para a Inteligência Artificial (APPIA), afirmou que as novas aplicações e ferramentas de Inteligência Artificial (IA) como a ChatGPT vão destruir muitos empregos, mas, por outro lado, vão também permitir ao ser humano trabalhar menos e ser mais feliz.

“No futuro, penso que esta revolução da IA e da robótica, que vai surgir a seguir, vai retirar emprego, mas o que penso sobretudo é que os humanos vão trabalhar menos no futuro. Trabalhar menos em tarefas mais interessantes, deixando para as máquinas grande parte das tarefas menos interessantes”, disse Luís Paulo Reis, considerando que o objetivo da IA é ajudar o ser humano a ser mais feliz, tendo as máquinas a trabalhar para e com a espécie humana.

O cientista da era da Inteligência Artificial e da Robótica reconhece, todavia, que a automação em geral, a transição digital, a digitalização, a inteligência artificial e a robótica vão retirar muitos empregos.

“Há empregos que vão desaparecer. O emprego de camionista, maquinista, motorista de autocarro. Muito desses empregos, muito provavelmente, vão desaparecer num futuro próximo e muito outros vão desaparecer, inclusivamente , o emprego do programador básico que faz programas simples. Neste momento é facilmente substituível por uma IA, que é capaz de programar com uma descrição de alto nível um programa equivalente ao que essa pessoa faria”, explica.

No entanto há outros empregos que vão ser potenciados, como os “empregos mais criativos”, ressalva.

Os modelos de inteligência artificial generativa, como as ChatGPT, são capazes de a partir de um texto simples gerar, criar textos extremamente complexos, com resposta a questões, com criação de novas questões, criação de conteúdo, peças jornalísticas, programas para disciplinas do ensino superior ou do ensino secundários, respostas a exames, criar inclusivamente exames, são capazes de ajudar a criar todo o tipo de textos ou desenvolver tarefas que levaríamos imenso tempo a desenvolvê-las e que podemos desenvolver muito mais rápido, exemplificou Luís Paulo Reis.

Em termos de benefícios, Luís Paulo Reis refere que o ChatGPT vai permitir, sobretudo, a “aceleração” do trabalho do dia a dia, “na forma de aprendizagem” ou na “forma de desenvolvimento de trabalho científico”.

“Usando este tipo de ferramentas, conseguimos acelerar imenso e ser muito mais produtivos”.

Há também riscos de fraude, alerta, e por isso vai ter de haver um “modelo rigoroso para que IA seja treinada com dados corretos”

“Estamos a chegar a um novo mundo com a IA, em que as tarefas intelectuais dos humanos deixam de ser exclusivas dos humanos e parece que as vão fazer melhor que nós. A tecnologia é imparável e temos que nos adaptar aos novos desafios”, defende, lembrando os tratores também substituirão os cavalos no passado.

O cientista recordou que já existem robots comerciais que nos representam, mas ainda muito simples e que no futuro existirão aplicações, robots que podem representar o ser humano em reuniões e que se vão poder controlar à distância.

O presidente da Associação Portuguesa de Inteligência Artificial acredita que as pessoas que trabalham no meio de IA não vão ter falta de emprego.

O cientista disse que os estudantes que estão a terminar agora o 12.º e que queiram seguir esta área, devem seguir engenharia informática de computação ou a área da Inteligência Artificial e Ciência de Dados, em que há já um curso da cooperação entre a Faculdade de Ciências e de Engenharia da Universidade do Porto.

“Esta área é excelente quer a nível de vencimento para os profissionais que se licenciam, sobretudo que fazem mestrados ou doutoramentos nesta área, conseguem excelentes empregos em empresas de topo, na Google, na Google DeepMind Technologies, na Sonny, nas grandes empresas mundiais, porque é uma área que precisa de imensos profissionais muito qualificados que sejam capazes de criar as novas ferramentas de IA e os novos robots”.

Questionado pela Lusa sobre quais as qualidades que os alunos devem ter para entrar nestes cursos de IA, o especialista e professor na faculdade de Engenharia do Porto mais cerca de 400 publicações científicas em revistas científicas sublinha que os alunos precisam de ser “inteligentes”.

“A inteligência é aquela capacidade de resolver novos problemas através da utilização de conhecimento”, explicou, elencando que a matemática mostra muitas vezes a inteligência, porque a matemática “é isso”.

“Nós vamos sempre resolver novos problemas utilizando o conhecimento, mas a física, a lógica, a capacidade algorítmica. O método para resolver um problema” ou “qualidades interpessoais” são todos importantes para realizar um curso destes no ensino superior.

Concordo na integra com esta perspectiva.



O ChatGTP apesar das limitações consegue realizar uma tarefa que era exclusivamente reservada a humanos, compilar informação de forma minimamente estruturada a partir de um input genérico. Nunca existiu nada deste tipo e tem de se considerar que estamos em fase beta da tecnologia. Estamos a falar de uma tecnologia que é capaz de realizar TPCs de ensino básico com excelentes resultados, em varias línguas. A tecnologia per se pode nem ser nada extraordinário mas o resultado para mim continua a ser um verdadeiro milestone na historia da humanidade.

[MarcoAntonio]

Agora não confundir IA com inteligência, a IA aqui é principalmente aproveitada para conseguir construir frases sintática e semanticamente correctas.

Não é bem isso. O mecanismo central nos modelos Transformer é o mecanismo de attention (atenção). A um nível básico, o que o mecanismo faz é determinar quais são as palavras mais importantes num pedaço de texto e como se relacionam com as outras palavras na mesma sequência de texto. O modelo não é propriamente treinado para construir frases com sintaxe correcta (muito embora uma das sub-tarefas da fase de fine-tuning tenha que ver com a qualidade gramatical, isso é só uma pequena parte do treino) nem é explicitamente informado sobre o significado semantico das palavras (na verdade, grande parte do treino é de resto não supervisionado). O mecanismo de attention é uma forma indirecta de capturar o contexto numa sequência (não quer dizer que a máquina realmente entenda o contexto; ela não faz ideia do que é que as palavras significam, está meramente a gerar textos "plausíveis" de acordo com o treino a que foi sujeita). A ideia geral foi proposta aqui e tem conduzido a vários sucessos interessantes em tarefas de machine learning (o mecanismo de attention já existia antes, mas a ideia de construir uma rede neuronal em torno só deste conceito - ie, o Transformer - surge aqui neste paper).

Sobre o facto de repetir trechos que escrevemos, é em larga medida um artefacto que decorre dele ter acesso aos últimos 4 mil tokens da conversação corrente para manter uma conversa (e sim, é fácil manipula-lo e leva-lo a dizer tremendos disparates, como se tem mostrado aqui no tópico).

Note-se também que este comportamento pode ser a priori limitado com LLMs que tenham acesso à web para verificar a informação, coisa que o ChatGPT não está a fazer.

[alfa_2]

Sem dúvida que é interessante o que o ChatGPT consegue fazer, mas parece-me que há aqui no meio uma “jogada” de marketing bastante forte (com muita gente a tentar tirar dividendos da “euforia” generalizada, nomeadamente a Microsoft a tentar aproveitar a “onda”). Toda a gente fala e escreve artigos do “assunto da moda” e, mas como habitual a maioria não faz a mínima do que está a falar. E claro, quando se fala de “jornalismo” há que extrapolar e pintar a coisa ao máximo, porque senão nem era notícia.
As limitações são ainda muitas, e é fácil encontrar um padrão nas respostas, típicas das máquinas e da programação (mesmo tendo esta com alguma IA á mistura). Agora não confundir IA com inteligência, a IA aqui é principalmente aproveitada para conseguir construir frases sintática e semanticamente correctas.

Ainda assim é interessante brincar com o CHAT, e metê-lo em contradição...

[MarcoAntonio]

Aqui fica um outro exemplo de aplicação de Transformers, no caso, trata-se de um sintetizador de voz que gera fala sintética a partir de um prompt de texto e um curto exemplo de audio do orador que queremos emular.

Neural Codec Language Models are Zero-Shot Text to Speech Synthesizers


[nota: zero-shot aqui refere-se ao modelo gerar voz para dados (oradores) que não viu durante o treino, ou seja, ele emula um orador que só está a ser utilizado durante a fase de teste/inferência; isto é diferente de treinar um modelo para emular os speakers do dataset e depois testar com textos "novos" para produzir novas sequências de fala, que é digamos a abordagem mais clássica; há vocoders neuronais actualmente que produzem voz sintética com melhor qualidade do que aquilo, o notável neste trabalho é conseguir gerar audio com aquela qualidade a partir de uma amostra tão curta e que está a ver pela primeira vez]

[MarcoAntonio]

O bias está "contido" nos dados de treino. O modelo tenderá a reflectir qualquer bias que já esteja nos dados de treino.

O exemplo mais simples de perceber é talvez o ponto do ChatGPT ser "pro-ambiente". Não há por aí muita gente a "defender" que as alterações climáticas são uma coisa boa; os que são "contra" não é para dizer que sim senhor é bom alterar o clima, mas mais para dizer coisas tipo que o clima não está a mudar; ou que está a mudar mas a causa não é humana; mas mesmo estes são uma minoria em termos de literatura científica, uma minoria muito pequena. Logo é natural que o treino do ChatGPT o leve a ser "pró-ambiente".

Além disso, este tipo de comportamento pode ser reforçado durante o RLHF (reinforcement learning from human feedback; durante o qual o treino segue um esquema/estratégia diferente e onde os utilizadores e o modelo inverteram papéis). O que também não precisa de ser resultado de um acto deliberado (pode acontecer como reflexo do próprio bias natural dos developers).

(nota: pode sempre alegar-se que é deliberado, mas não há nenhuma razão em especial para achar que é deliberado)

[BearManBull]

Quanto ao resto, o meu ponto é i) que está documentado que o ChatGPT tem algum bias (enviezamento)

Como é que produzem o bias? Retiram dados dos modelos de treino?

[MarcoAntonio]

João Gabriel Ribeiro, que é um sabedor da matéria, fala em não gratituidade, refere um sistema de créditos. Penso que a ser usado futuramente.

Actualmente, dos serviços que eu mencionei que já foram disponibilizados publicamente, estão todos disponíveis gratuitamente (alguns com planos de utilização paga para expandir o serviço, o que é normalíssimo).

Mas é fantástico que estejam todos disponíveis gratuitamente (estima-se por exemplo que o ChatGPT esteja a custar milhões de dolares por mês à OpenAI). Desenvolver, treinar e manter estes serviços com modelos desta escala não é barato (muito embora, com o tempo os custos venham a cair, naturalmente).

[Àlvaro]

João Gabriel Ribeiro, que é um sabedor da matéria, fala em não gratituidade, refere um sistema de créditos. Penso que a ser usado futuramente.

[MarcoAntonio]

Tem ainda um senão, não é grátis.

O que é que não é grátis?

[Àlvaro]

Tem ainda um senão, não é grátis.

[MarcoAntonio]

E já que se está com a mão na massa, não esquecer os modelos generativos que estão a ser desenvolvidos para outras tarefas, como o Dall-E e o Midjourney (entre outros), capazes de produzir imagens de vários tipos, ou os sintetizadores neuronais, capazes de produzir voz e música, a partir de descrições textuais...



"watercolor in the style of Cezanne of a druid brewing magic potions in his cauldron"

DALL-E:






"3d render of a machine with cubic microchips filled with small lights, interconnected with lighten up fiber optics, a redish glow with a cyberpunk tone"

DALL-E:





"old photography in sepia tones of a man in a 1966 lab operating a computer"

DALL-E:

[MarcoAntonio]

Já agora, aqui ficam os três principais modelos deste tipo que têm estado a ser desenvolvidos:

GPT - em que o ChatGPT se baseia, assim como o Prometheus da Microsoft
LaMDA - de onde saiu o Bard da Google
OPT - modelo da Meta/Facebook, que tem estado mais "silenciosa" (mas que por sinal há um ano atrás era o maior LLM)

Todos eles são Transformer-based (um tipo de arquitectura de rede neuronal) e funcionam com base em princípios bastante semelhantes. Há outros modelos baseados em arquitecturas diferentes.





Aqui fica o paper mais recente da Meta, acerca do OPT, para complementar aos que já tinha partilhado acerca do GPT e do LaMDA.

https://arxiv.org/pdf/2212.12017.pdf

[MarcoAntonio]

O tipo de aplicação em si vai revolucionar a forma como as pessoas vão passar a utilizar os motores de busca (eles vão ser integrados nos motores de busca). O impacto que vai ter a longo prazo, ainda está para ver (também na medida em que os modelos forem melhorando, o que é difícil de prever).

Entretanto, quer a integração nos motores de busca, quer a utilização de API's que permitem a integração com outras ferramentas (como o Wolfram, conforme já mencionei aqui um par de vezes, a título de exemplo) poderá ajudar a limitar as diversas falhas/limitações que a versão do ChatGPT (na prática, é uma "demo") tem e que se têm discutido aqui de uma forma geral. Este tipo de evolução, julgo que a veremos no espaço de meses.

Depois mais além, logo se vê...

[Àlvaro]

Pelo que consigo testar vejo que há um deslumbramento exagerado com esta geringonça que faz um pouco mais que a Google já faz. Sintetiza melhor, recorre a mais dados, mas está longe de ser essa coisa de grande novidade.

[MarcoAntonio]

Algo que gostava de saber sera que a IA procura ser simpática pensado no que quem lhe pede gosta de ler .

O chatGPT não pensa, não tem capacidade de raciocínio nem tenta agradar ninguém.

O chatGPT não faz ideia sequer do que é que as palavras que produz significam.

O que o modelo produz é meramente um texto "plausível" com base em probabilidades (extraídas dos dados de treino).


Além disso, tem ainda algumas medidas de segurança adicionais para filtrar conteúdos (impedir determinadas respostas) mas que não funciona de forma perfeita (e/ou equilibrada).




Quanto ao resto, o meu ponto é i) que está documentado que o ChatGPT tem algum bias (enviezamento), nomeadamente dito de esquerda e também pró-ambiental (ver por exemplo o paper que partilho acima) e ii) que a minha experiência pessoal vai também no mesmo sentido (i.e., constato que o tal bias existe) mas iii) que não é bem como está apresentado na crónica de cima. Na verdade, existem também exemplos documentados bem diferentes e, de resto, qualquer um pode experimentar. Desde que faça experiências várias e diversificadas, vai ver que não é exactamente aquele "dá só para um lado" como está na crónica acima, isso não é bem verdade e é fácil de verificar.