Portos de Lisboa e Sines crescem com crise no mar Vermelho

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

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