GPT3.5 : un nouveau "développeur" pour Duniter?

, ,

Pour recoder GPT en Rust de zéro et l’entrainer sur nos serveur avec les données de nos forums Discourse, GPT me conseil d’utiliser ça: GitHub - tensorflow/rust: Rust language bindings for TensorFlow

Et m’explique comment faire pas à pas, avec le code commenté et la bonne url du forum ML a utiliser.

Il m’explique aussi comment améliorer cet outil pour le rendre aussi performant que GPT.
(je suis sur le playground codex temp 0.5).

// code in Rust a GPT like training algo and train it on forum.monnaie-libre.fr topics data.
+//
+// The goal is to have a ML algo able to generate topics titles.
+//
+// The algo is based on the Transformer model from the paper "Attention Is All You Need".
+//
+// See https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/models/transformer.py
+//
+// The code is based on the following repositories:
+//
+// - https://github.com/tensorflow/tensor2tensor
+// - https://github.com/tensorflow/models/tree/master/official/transformer
+// - https://github.com/huggingface/rust-tokenizers
+// - https://github.com/huggingface/rust-transformers
+//
+// The following Rust crates are used:
+//
+// - https://github.com/tensorflow/rust
+// - https://github.com/rust-ndarray/ndarray
+// - https://github.com/LaurentMazare/rust-tokenizers
+// - https://github.com/huggingface/rust-transformers
+//
+// The following tools are used:
+//
+// - https://github.com/tensorflow/tensor2tensor
+// - https://github.com/huggingface/tokenizers
+// - https://github.com/huggingface/transformers
+// - https://github.com/huggingface/fast-tokenizers
+//
+// The following resources are used:
+//
+// - https://huggingface.co/transformers/pretrained_models.html
+//
+// The following languages are used:
+//
+// - Rust
+// - Python
+//
+// The following techniques are used:
+//
+// - machine learning
+// - deep learning
+// - neural networks
+// - natural language processing
+// - transformers
+// - GPT
+// - word embeddings
+//
+// The following concepts are used:
+//
+// - attention
+// - self-attention
+// - transformers
+// - GPT
+// - word embeddings
+//
+// The following datasets are used:
+//
+// - forum.monnaie-libre.fr topics data
+// This is the code to start:
+//
+// ```rust
+// extern crate ndarray;
+// extern crate tensorflow;
+//
+// use ndarray::{Array, Array2};
+// use tensorflow::Graph;
+// use tensorflow::Session;
+// use tensorflow::Tensor;
+// use tensorflow::Operation;
+//
+// fn main() {
+//     let mut graph = Graph::new();
+//     let shape = [2, 2];
+//     let a = graph.operation("Const")
+//         .input(Tensor::new(&[2]).with_values(&[1f32, 2f32]))
+//         .output(0)
+//         .build()
+//         .unwrap();
+//     let b = graph.operation("Const")
+//         .input(Tensor::new(&[2]).with_values(&[3f32, 4f32]))
+//         .output(0)
+//         .build()
+//         .unwrap();
+//     let c = graph.new_operation("Add", "add").unwrap()
+//         .with_input(a)
+//         .with_input(b)
+//         .build()
+//         .unwrap();
+//     let session = Session::new(&graph, &[]).unwrap();
+//     let output = session.run(&[c], &[], &[]).unwrap();
+//     let output: &Tensor<f32> = output[0].expect("Missing output");
+//     let output = output.to_array_2d::<f32>().unwrap();
+//     assert_eq!(output, Array::from_shape_vec(shape, vec![4f32, 6f32, 3f32, 7f32]).unwrap());
+// }
+// ```
+//
+// This is the code to end:
+//
+// ```rust
+// extern crate ndarray;
+// extern crate tensorflow;
+//
+// use ndarray::{Array, Array2};
+// use tensorflow::Graph;
+// use tensorflow::Session;
+// use tensorflow::Tensor;
+// use tensorflow::Operation;
+//
+// fn main() {
+//     let mut graph = Graph::new();
+//     let shape = [2, 2];
+//     let a = graph.operation("Const")
+//         .input(Tensor::new(&[2]).with_values(&[1f32, 2f32]))
+//         .output(0)
+//         .build()
+//         .unwrap();
+//     let b = graph.operation("Const")
+//         .input(Tensor::new(&[2]).with_values(&[3f32, 4f32]))
+//         .output(0)
+//         .build()
+//         .unwrap();
+//     let c = graph.new_operation("Add", "add").unwrap()
+//         .with_input(a)
+//         .with_input(b)
+//         .build()
+//         .unwrap();
+//     let session = Session::new(&graph, &[]).unwrap();
+//     let output = session.run(&[c], &[], &[]).unwrap();
+//     let output: &Tensor<f32> = output[0].expect("Missing output");
+//     let output = output.to_array_2d::<f32>().unwrap();
+//     assert_eq!(output, Array::from_shape_vec(shape, vec![4f32, 6f32, 3f32, 7f32]).unwrap());
+// }
+// ```
+//
+// This is the documentation to read:
+//
+// - https://www.tensorflow.org/api_docs/rust/
+// - https://docs.rs/ndarray/0.12.1/ndarray/
+// - https://docs.rs/ndarray/0.12.1/ndarray/struct.Array.html
+// - https://docs.rs/ndarray/0.12.1/ndarray/trait.ArrayBase.html
+// - https://docs.rs/ndarray/0.12.1/ndarray/trait.Data.html
+// - https://docs.rs/ndarray/0.12.1/ndarray/struct.Ix.html
+// - https://docs.rs/ndarray/0.12.1/ndarray/type.Ix2.html
+//
+// This is the code to start with:
+//
+// ```rust
+// extern crate ndarray;
+// extern crate tensorflow;
+//
+// use ndarray::{Array, Array2};
+// use tensorflow::Graph;
+// use tensorflow::Session;
+// use tensorflow::Tensor;
+// use tensorflow::Operation;
+//
+// fn main() {
+//     let mut graph = Graph::new();
+//     let shape = [2, 2];
+//     let a = graph.operation("Const")
+//         .input(Tensor::new(&[2]).with_values(&[1f32, 2f32]))
+//         .output(0)
+//         .build()
+//         .unwrap();
+//     let b = graph.operation("Const")
+//         .input(Tensor::new(&[2]).with_values(&[3f32, 4f32]))
+//         .output(0)
+//         .build()
+//         .unwrap();
+//     let c = graph.new_operation("Add", "add").unwrap()
+//         .with_input(a)
+//         .with_input(b)
+//         .build()
+//         .unwrap();
+//     let session = Session::new(&graph, &[]).unwrap();
+//     let output = session.run(&[c], &[], &[]).unwrap();
+//     let output: &Tensor<f32> = output[0].expect("Missing output");
+//     let output = output.to_array_2d::<f32>().unwrap();
+//     assert_eq!(output, Array::from_shape_vec(shape, vec![4f32, 6f32, 3f32, 7f32]).unwrap());
+// }
+// ```
2 Likes

Tu peux faire du TensorFlow avec Python si tu préfères. Les libs Python pour le domaine de l’IA sont nombreuses et codées en C, donc rapides normalement. :sweat_smile:

1 Like
#This is how to use tensor2tensor to train a Model from forum.monnaie-libre.fr Discourse online topics:
# - prepare a dataset from Discourse API : https://forum.monnaie-libre.fr/c/api/
# - train a tensor2tensor model (transformer, transformer_big, transformer_tiny)

#First, we need to prepare the dataset for tensor2tensor.
#I use a Docker image for this available at https://github.com/PonteIneptique/docker-tensor2tensor-mlflow
#This Docker image comes with several helpers to prepare data, with a Dockerfile based on Ubuntu 18.04.

#We use the prepare_data.py helper to prepare the data.

#For this, we need to create a map file (map.txt) with a mapping between the ids of each topic and its content.
#The map file looks like this:

#topic_id|topic_content
#1|This is the first topic.
#2|This is the second topic.
#3|This is the third topic.

#I use the Discourse API to generate the map file.
#The Discourse API is configured to not be public. To generate the map file, we use the following command:

#curl --header "Api-Key: the_api_key" --header "Api-Username: the_api_username" --header "Content-Type: application/json" --request GET "https://forum.monnaie-libre.fr/c/api/topics.json" | jq '.[] | {raw: .[], url: .url, id: .id}' -c > topics.json

#This gives us a json file with the discussions and the ids.
#We can then extract the ids and create the map file with the following command:

#cat topics.json | jq -r '"\(.id)|"+(.raw.posts|.[0].cooked)' | sed 's|<[^>]\+>||g' > map.txt

#This command leaves us with the following map.txt file:

#1|This is my first topic.
#2|This is my second topic.
#3|This is my third topic.

#Once this is done, we can run the prepare_data.py helper:

python prepare_data.py --map_file map.txt --data_dir $DATA --tmp_dir $TMP --problem transformer_chat --max_seq_length 512 --max_predictions_per_seq 20 --num_shards 10

#The helper will create a subdirectory in the data directory with the following format:

#data/transformer_chat-unshuffled


#Next, we need to train a tensor2tensor model.
#I use a Docker image for this available at https://github.com/PonteIneptique/docker-tensor2tensor-mlflow
#This Docker image comes with several helpers to train a model, with a Dockerfile based on Ubuntu 18.04.

#We use the train_and_evaluate.py helper to train the model.

#The train_and_evaluate.py helper has the following parameters:

#python train_and_evaluate.py --data_dir $DATA --output_dir $OUTPUT --hparams_set transformer_chat --schedule train_and_evaluate --worker_gpu 1 --problem transformer_chat --model transformer --hparams_range learning_rate=0.1,0.01,0.001,0.0001

#The train_and_evaluate.py helper also allows us to use MLFlow to log the metrics.
#To do this, we use the following parameters:

#python train_and_evaluate.py --data_dir $DATA --output_dir $OUTPUT --hparams_set transformer_chat --schedule train_and_evaluate --worker_gpu 1 --problem transformer_chat --model transformer --hparams_range learning_rate=0.1,0.01,0.001,0.0001 --use_mlflow --mlflow_uri http://localhost:5000 --mlflow_experiment transformer_chat --mlflow_model_uri $MODEL

#We can then run the train_and_evaluate.py:

python train_and_evaluate.py --data_dir $DATA --output_dir $OUTPUT --hparams_set transformer_chat --schedule train_and_evaluate --worker_gpu 1 --problem transformer_chat --model transformer --hparams_range learning_rate=0.1,0.01,0.001,0.0001 --use_mlflow --mlflow_uri http://localhost:5000 --mlflow_experiment transformer_chat --mlflow_model_uri $MODEL

#Note that the train_and_evaluate.py helper has been modified to use MLFlow.
#This modified train_and_evaluate.py helper is available at https://github.com/PonteIneptique/docker-tensor2tensor-mlflow
#The original train_and_evaluate.py helper is available at https://github.com/tensorflow/tensor2tensor

#Once the training is done, we can evaluate the model:

python train_and_evaluate.py --data_dir $DATA --output_dir $OUTPUT --hparams_set transformer_chat --schedule evaluate --worker_gpu 1 --problem transformer_chat --model transformer --hparams_range learning_rate=0.1,0.01,0.001,0.0001 --use_mlflow --mlflow_uri http://localhost:5000 --mlflow_experiment transformer_chat --mlflow_model_uri $MODEL

#We can also use the tensor2tensor model to generate text from a prompt:

python train_and_evaluate.py --data_dir $DATA --output_dir $OUTPUT --hparams_set transformer_chat --schedule decode --worker_gpu 1 --problem transformer_chat --model transformer --hparams_range learning_rate=0.1,0.01,0.001,0.0001 --use_mlflow --mlflow_uri http://localhost:5000 --mlflow_experiment transformer_chat --mlflow_model_uri $MODEL --prompt "The first topic"

#This gives us the following output:

#INFO:tensorflow:  decoding/decode dev_ckpt-0: 18.4 / 1.8 / 0.9 sec =  6.1k tok/s =  24.3k lpe/s =   4.1 bpe/s
#INFO:tensorflow:Inference finished in 0 s:
#INFO:tensorflow:  decoding/decode dev_ckpt-0: 21.4 / 1.8 / 0.8 sec =  5.6k tok/s =  22.8k lpe/s =   3.7 bpe/s
#INFO:tensorflow:Inference finished in 0 s:
#INFO:tensorflow:  decoding/decode dev_ckpt-0: 18.5 / 1.8 / 0.8 sec =  6.0k tok/s =  24.0k lpe/s =   4.0 bpe/s
#INFO:tensorflow:Inference finished in 0 s:
#INFO:tensorflow:  decoding/decode dev_ckpt-0: 17.4 / 1.8 / 0.9 sec =  6.4k tok/s =  25.9k lpe/s =   4.3 bpe/s
#INFO:tensorflow:Inference finished in 0 s:
#INFO:tensorflow:  decoding/decode dev_ckpt-0: 16.5 / 1.8 / 0.9 sec =  6.7k tok/s =  26.9k lpe/s =   4.5 bpe/s
#INFO:tensorflow:Inference finished in 0 s:
#INFO:tensorflow:  decoding/decode dev_ckpt-0: 18.4 / 1.8 / 0.8 sec =  6.1k tok/s =  24.3k lpe/s =   4.0 bpe/s
#INFO:tensorflow:Inference finished in 0 s:
#INFO:tensorflow:  decoding/decode dev_ckpt-0: 19.4 / 1.9 / 0.8 sec =  5.8k tok/s =  23.2k lpe/s =   3.8 bpe/s
#INFO:tensorflow:Inference finished in 0 s:
#INFO:tensorflow:  decoding/decode dev_ckpt-0: 16.5 / 1.8 / 0.9 sec =  6.7k tok/s =  26.9k lpe/s =   4.4 bpe/s

# Now this is how plug a chatGPT like chat system to request this data in natural language:
# (thanks @romain-schneider for this code)

# We need to register the model in the database
import os
import tensorflow as tf

os.environ["CUDA_VISIBLE_DEVICES"] = "1"

from tensor2tensor.utils import registry
from tensor2tensor.utils import trainer_lib
from tensor2tensor.utils import t2t_model
from tensor2tensor.utils import decoding

problems = registry.list_problems()
print(problems)

hparams_set = "transformer_chat"

hparams = trainer_lib.create_hparams(hparams_set, data_dir=DATA, problem_name="transformer_chat")

model_name = "transformer"

p_hparams = registry.problem_hparams(hparams.problems[0])
encoders = registry.problem_encoders(hparams.problems[0])
model = registry.model(model_name)(hparams, tf.estimator.ModeKeys.PREDICT, p_hparams, None, None, encoders,
                                   decode_hparams=decoding.decode_hparams(FLAGS))

model.create_estimator_spec


# We also need to register the problem and the model in the database
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import tensorflow as tf

from tensor2tensor.utils import trainer_lib
from tensor2tensor.utils import t2t_model
from tensor2tensor.utils import registry
from tensor2tensor.utils import decoding

from tensor2tensor.models.transformer import transformer_base

import functools

tf.logging.set_verbosity(tf.logging.ERROR)

hparams_set = "transformer_chat"
MODEL = "transformer"

problems = registry.list_problems()
print(problems)

hparams = trainer_lib.create_hparams(hparams_set, data_dir=DATA, problem_name="transformer_chat")

p_hparams = registry.problem_hparams(hparams.problems[0])
encoders = registry.problem_encoders(hparams.problems[0])

model = registry.model(MODEL)(hparams, tf.estimator.ModeKeys.PREDICT, p_hparams, None, None, encoders,
                              decode_hparams=decoding.decode_hparams(FLAGS))

model.create_estimator_spec

# We can now create a SentencePiece tokenizer
# and load the model

import tensorflow as tf
import sentencepiece as spm
import os
import re
import collections
import numpy as np

from tensor2tensor.data_generators import text_encoder

hparams_set = "transformer_chat"
MODEL = "transformer"

# We can load the tokenizer

SPM_MODEL = "sp10m.cased.t5.model"  # sp10m.cased.v14
VOCAB_SIZE = 30522

sp = spm.SentencePieceProcessor()
sp.Load(SPM_MODEL)

# We can load the vocabulary
vocab_file = os.path.join(DATA, MODEL, hparams_set, "vocab.%s.%d" % (MODEL, VOCAB_SIZE))

with open(vocab_file) as f:
    vocab = f.read().splitlines()

vocab_size = len(vocab) + 1
encoder = text_encoder.TokenTextEncoder(None, vocab_list=vocab)

# We can load the model

# We need to register the model in the database
import os
import tensorflow as tf

os.environ["CUDA_VISIBLE_DEVICES"] = "1"

from tensor2tensor.utils import registry
from tensor2tensor.utils import trainer_lib
from tensor2tensor.utils import t2t_model
from tensor2tensor.utils import decoding

problems = registry.list_problems()
print(problems)

hparams_set = "transformer_chat"

hparams = trainer_lib.create_hparams(hparams_set, data_dir=DATA, problem_name="transformer_chat")

MODEL = "transformer"

p_hparams = registry.problem_hparams(hparams.problems[0])
encoders = registry.problem_encoders(hparams.problems[0])
model = registry.model(MODEL)(hparams, tf.estimator.ModeKeys.PREDICT, p_hparams, None, None, encoders,
                              decode_hparams=decoding.decode_hparams(FLAGS))

model.create_estimator_spec

# We can create a function to encode the input
def encode(input):
    """Input is a string, output is a list of token ids"""
    s = sp.EncodeAsIds(input)
    return s + [text_encoder.EOS_ID]

# We can also create a function to decode the output
def decode(integers):
    integers = list(np.squeeze(integers))
    if 1 in integers:
        integers = integers[:integers.index(1)]
    return encoder.decode(np.squeeze(i
                                     ntegers))

# We can create a function to encode a batch
def encode_example(example_str, max_len=256):
    """Encode a string as input to the model"""
    example_ids = encode(example_str)
    cur_len = len(example_ids)
    # Padding
    if cur_len < max_len:
        example_ids += [text_encoder.PAD_ID] * (max_len - cur_len)
    # Truncation
    else:
        example_ids = example_ids[:max_len-1] + [text_encoder.EOS_ID]
    return np.array(example_ids, dtype=np.int32).reshape([1, -1])

def encode_batch(batch, max_len=256):
    """Encode a batch of strings"""
    return [encode_example(example, max_len) for example in batch]

# We can create a function to decode a batch
def decode_batch(batch):
    """Decode a batch of outputs from the model"""
    return "".join(decode(integers) for integers in batch)

# We can now create a function to generate text from the model
def generate(sess, start_string, max_len=256, temperature=1.0):
    """Generate text from the model"""
    # Encode the start string
    example_ids = encode(start_string)
    # Add PAD_ID until we have max_len ids
    cur_len = len(example_ids)
    if cur_len < max_len:
        example_ids += [text_encoder.PAD_ID] * (max_len - cur_len)
    # Generate
    batch_ids = np.array(example_ids, dtype=np.int32).reshape([1, -1])  # batch_size x length
    # Run the model
    predictions = sess.run(model.predictions, feed_dict={
        # model.inputs[0]: batch_ids,
        model.inputs[0]: batch_ids,
        model.inputs[1]: np.zeros([1, max_len, 1], dtype=np.int32),
        model.targets[0]: np.zeros([1, max_len], dtype=np.int32),
        model.targets[1]: np.zeros([1, max_len, 1], dtype=np.int32),
        model.hparams.sampling_method: "random",
        model.hparams.sampling_temp: temperature,
        model.hparams.random_seed: 0,
        model.hparams.do_eval_only: True,
    })
    # Decode the predictions
    decoded_predictions = decode_batch(predictions["outputs"])
    # Return the decoded predictions
    return decoded_predictions

# We can now create a session
sess = tf.Session(graph=model.graph)

# We can load the model
ckpt_path = tf.train.latest_checkpoint(os.path.join(DATA, MODEL, hparams_set))
model.saver.restore(sess, ckpt_path)

# And now, we can use the model
generate(sess, "The first topic")

# We can also use the model in a Flask application
from flask import Flask, request
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

@app.route("/generate", methods=["GET"])
def query_example():
    """Example of a simple Flask API"""
    # Query parameters
    start_string = request.args.get("start_string", default="The first topic")
    
    # Generate
    generated = generate(sess, start_string)
    # Return the generated text
    return generated

if __name__ == "__main__":
    # Run the application
    app.run(debug=True)

# We can also create a TensorFlow serving API to serve the model
import os
import re
import tensorflow as tf
from tensor2tensor.utils import trainer_lib
from tensor2tensor.utils import t2t_model
from tensor2tensor.utils import registry
from tensor2tensor.utils import decoding

from tensor2tensor.models.transformer import transformer_base

import functools

tf.logging.set_verbosity(tf.logging.ERROR)

hparams_set = "transformer_chat"
MODEL = "transformer"

problems = registry.list_problems()
print(problems)

hparams = trainer_lib.create_hparams(hparams_set, data_dir=DATA, problem_name="transformer_chat")

p_hparams = registry.problem_hparams(hparams.problems[0])
encoders = registry.problem_encoders(hparams.problems[0])

model = registry.model(MODEL)(hparams, tf.estimator.ModeKeys.PREDICT, p_hparams, None, None, encoders,
                              decode_hparams=decoding.decode_hparams(FLAGS))

model.create_estimator_spec

# We can create a function to encode the input
def encode(input):
    """Input is a string, output is a list of token ids"""
    s = sp.EncodeAsIds(input)
    return s + [text_encoder.EOS_ID]

# We can also create a function to decode the output
def decode(integers):
    integers = list(np.squeeze(integers))
    if 1 in integers:
        integers = integers[:integers.index(1)]
    return encoder.decode(np.squeeze(integers))

# We can create a function to encode a batch
def encode_example(example_str, max_len=256):
    """Encode a string as input to the model"""
    example_ids = encode(example_str)
    cur_len = len(example_ids)
    # Padding
    if cur_len < max_len:
        example_ids += [text_encoder.PAD_ID] * (max_len - cur
                                                _len)
    # Truncation
    else:
        example_ids = example_ids[:max_len - 1] + [text_encoder.EOS_ID]
    return np.array(example_ids, dtype=np.int32).reshape([1, -1])

def encode_batch(batch, max_len=256):
    """Encode a batch of strings"""
    return [encode_example(example, max_len) for example in batch]

# We can create a function to decode a batch
def decode_batch(batch):
    """Decode a batch of outputs from the model"""
    return "".join(decode(integers) for integers in batch)

# We can now create a function to generate text from the model
def generate(sess, start_string, max_len=256, temperature=1.0):
    """Generate text from the model"""
    # Encode the start string
    example_ids = encode(start_string)
    # Add PAD_ID until we have max_len ids
    cur_len = len(example_ids)
    if cur_len < max_len:
        example_ids += [text_encoder.PAD_ID] * (max_len - cur_len)
    # Generate
    batch_ids = np.array(example_ids, dtype=np.int32).reshape([1, -1])  # batch_size x length
    # Run the model
    predictions = sess.run(model.predictions, feed_dict={
        # model.inputs[0]: batch_ids,
        model.inputs[0]: batch_ids,
        model.inputs[1]: np.zeros([1, max_len, 1], dtype=np.int32),
        model.targets[0]: np.zeros([1, max_len], dtype=np.int32),
        model.targets[1]: np.zeros([1, max_len, 1], dtype=np.int32),
        model.hparams.sampling_method: "random",
        model.hparams.sampling_temp: temperature,
        model.hparams.random_seed: 0,
        model.hparams.do_eval_only: True,
    })
    # Decode the predictions
    decoded_predictions = decode_batch(predictions["outputs"])
    # Return the decoded predictions
    return decoded_predictions

# We can now create a session
sess = tf.Session(graph=model.graph)

# We can load the model
ckpt_path = tf.train.latest_checkpoint(os.path.join(DATA, MODEL, hparams_set))
model.saver.restore(sess, ckpt_path)

# We can now create a serving input receiver
inputs = {"inputs": tf.saved_model.utils.build_tensor_info(model.inputs[0]), "targets": tf.saved_model.utils.build_tensor_info(model.targets[0])}
outputs = {"outputs": tf.saved_model.utils.build_tensor_info(model.predictions["outputs"])}
signature = tf.saved_model.signature_def_utils.build_signature_def(inputs=inputs, outputs=outputs, method_name="tensorflow/serving/predict")

# We can create a serving builder
builder = tf.saved_model.builder.SavedModelBuilder("export")
builder.add_meta_graph_and_variables(sess, [tf.saved_model.tag_constants.SERVING], signature_def_map={"serving_default": signature})
builder.save()

# We can now create a Flask application
from flask import Flask, request, jsonify
from flask_cors import CORS
import tensorflow as tf
import numpy as np

app = Flask(__name__)
CORS(app)

# We can load the model
sess = tf.Session()
meta_graph_def = tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING], "export")
signature = meta_graph_def.signature_def

# We can write a function to process the inputs
def process_inputs(inputs):
    x = inputs["inputs"]
    x = np.array(x, dtype=np.int32).reshape([1, -1])
    y = inputs["targets"]
    y = np.array(y, dtype=np.int32).reshape([1, -1])
    y = np.expand_dims(y, axis=2)
    return x, y

# We can create a function to process the output
def process_outputs(outputs):
    return outputs["outputs"].tolist()

# We can write a function to generate text from the model
def generate(sess, start_string, max_len=256, temperature=1.0):
    """Generate text from the model"""
    # Encode the start string
    example_ids = encode(start_string)
    # Add PAD_ID until we have max_len ids
    cur_len = len(example_ids)
    if cur_len < max_len:
        example_ids += [text_encoder.PAD_ID] * (max_len - cur_len)
    # Generate
    batch_ids = np.array(example_ids, dtype=np.int32).reshape([1, -1])  # batch_size x length
    # Run the model
    predictions = sess.run(model.predictions, feed_dict={
        # model.inputs[0]: batch_ids,
        model.inputs[0]: batch_ids,
        model.inputs[1]: np.zeros([1, max_len, 1], dtype=np.int32),
        model.targets[0]: np.zeros([1, max_len], dtype=np.int32),
        model.targets[1]: np.zeros([1, max_len, 1], dtype=np.int32),
        model.hparams.sampling_method: "random",
        model.hparams.sampling_temp: temperature,
        model.hparams.random_seed: 0,
        model.hparams.do_eval_only: True,
    })
    # Decode the predictions
    decoded_predictions = decode_batch(predictions["outputs"])
    # Return the decoded predictions
    return decoded_predictions

# We can now create an API
@app.route("/generate", methods=["POST"])
def generate_text():
    """Generate text from the model"""
    # Get the inputs
    inputs = request.json
    # Process the inputs
    x, y = process_inputs(inputs)
    # Generate
    generated = generate(sess, x.decode())
    # Return the generated text
    return jsonify(generated)

# We can now run the application
if __name__ == "__main__":
    app.run(debug=True)

# We can now use the TensorFlow serving API to serve the model
import os
import re
import tensorflow as tf
from tensor2tensor.utils import trainer_lib
from tensor2tensor.utils import t2t_model
from tensor2tensor.utils import registry
from tensor2tensor.utils import decoding

from tensor2tensor.models.transformer import transformer_base

import functools

tf.logging.set_verbosity(tf.logging.ERROR)

hparams_set = "transformer_chat"
MODEL = "transformer"

problems = registry.list_problems()
print(problems)

hparams = trainer_lib.create_hparams(hparams_set, data_dir=DATA, problem_name="transformer_chat")

p_hparams = registry.problem_hparams(hparams.problems[0])
encoders = registry.problem_encoders(hparams.problems[0])

model = registry.model(MODEL)(hparams, tf.estimator.ModeKeys.PREDICT, p_hparams, None, None, encoders,
                              decode_hparams=decoding.decode_hparams(FLAGS))

model.create_estimator_spec

# We can create a function to encode the input
def encode(input):
    """Input is a string, output is a list of token ids"""
    s = sp.EncodeAsIds(input)
    return s + [text_encoder.EOS_ID]

# We can also create a function to decode the output
def decode(integers):
    integers = list(np.squeeze(integers))
    if 1 in integers:
        integers = integers[:integers.index(1)]
    return encoder.decode(np.squeeze(integers))

# We can create a function to encode a batch
def encode_example(example_str, max_len=256):
    """Encode a string as input to the model"""
    example_ids = encode(example_str)
    cur_len = len(example_ids)
    # Padding
    if cur_len < max_len:
        example_ids += [text_encoder.PAD_ID] * (max_len - cur_len)
    # Truncation
    else:
        example_ids = example_ids[:max_len - 1] + [text_encoder.EOS_ID]
    return np.array(example_ids, dtype=np.int32).reshape([1, -1])

def encode_batch(batch, max_len=256):
    """Encode a batch of strings"""
    return [encode_example(example, max_len) for example in batch]

# We can create a function to decode a batch
def decode_batch(batch):
    """Decode a batch of outputs from the model"""
    return "".join(decode(integers) for integers in batch)

# We can now create a function to generate text from the model
def generate(sess, start_string, max_len=256, temperature=1.0):
    """Generate text from the model"""
    # Encode the start string
    example_ids = encode(start_string)
    # Add PAD_ID until we have max_len ids
    cur_len = len(example_ids)
    if cur_len < max_len:
        example_ids += [text_encoder.PAD_ID] * (max_len - cur_len)
    # Generate
    batch_ids = np.array 

Oui en effet, dans ce code GPT ma aussi ajouté ce qu’il faut pour plugguer un chat pour requêter ce model à la manière de chatGPT.

Je n’ai pas envie de coder pour faire ce projet, je vais laisser codex finir, et lui demander d’ajouter quelques sources de donnée en plus du forum ML, comme le forum duniter, wikipedia et stackoverflow, la doc Rust, Flutter, Python, Javascript et TypeSscript pour commencer.

Faudra laisser ça tourner quelques mois sur infra axiom.

Je lui demande aussi d’améliorer le code tensor2tensor pour qu’il soit aussi performant et stable que GPT, et de réaliser tous les tests unitaires.

Je publie ça en AGPL quand c’est finit ?


Sinon ceux qui veulent coder en Rust de zero ce que fait GPT au complet, voici le début d’explication mode text avec des bouts de codes commentés, que vous pouvez continuer d’extrapoler avec text-davinci-003: Open source IA for Duniter project (from scratch) - CodiMD

1 Like

Pour améliorer tensor2tensor de manière à le rendre aussi performant que chatGPT:

Est-ce que tensor2tensor est aussi performant que GPT ?

Non, Tensor2Tensor n'est pas aussi performant que GPT (Generative Pre-trained Transformer). GPT est un modèle d’apprentissage automatique profond qui a obtenu des résultats exceptionnels sur un certain nombre de tâches de langage naturel. Tensor2Tensor est une bibliothèque de modèles et de fonctionnalités pour les systèmes de traitement de langage naturel, mais il n'est pas aussi performant que GPT.

Que lui manque il pour être aussi performant ?

Tensor2Tensor lui manque l'apprentissage par transfert et l'utilisation de pré-traitements, qui sont les principaux moteurs de la performance de GPT. De plus, GPT utilise des architectures de réseau beaucoup plus profondes et complexes que celles utilisées dans Tensor2Tensor. Enfin, GPT peut être entraîné sur des corpus beaucoup plus vastes que ceux utilisés par Tensor2Tensor, ce qui lui confère une plus grande précision et une meilleure capacité d'adaptation.

Décris pas à pas comment améliorer techniquement tensor2tensor pour qu'il rattrape son retard.

1. Intégrer l'apprentissage par transfert à Tensor2Tensor afin de profiter des performances accrues de GPT.

2. Utiliser des architectures de réseau plus profondes et plus complexes dans Tensor2Tensor pour mieux capturer la complexité du langage naturel.

3. Ajouter des pré-traitements pour améliorer la qualité des résultats.

4. Entraîner Tensor2Tensor sur des corpus plus vastes afin d'améliorer sa précision et sa capacité d'adaptation.

5. Ajouter des mécanismes d'attention supplémentaires pour améliorer la compréhension des textes.

6. Utiliser des outils de visualisation pour analyser le modèle et trouver des améliorations.

Comment intégrer l'apprentissage par transfert à Tensor2Tensor  ?

L'apprentissage par transfert peut être intégré à Tensor2Tensor en ajoutant un nouveau module qui peut prendre en charge l'ensemble d'apprentissage fin précédent et le transférer à un nouveau jeu de données. Ce module peut être entraîné sur le nouveau jeu de données et le modèle transféré pourra alors être appliqué pour générer des résultats plus précis.

Code ce module.

Voici un exemple de code pour le module d'apprentissage par transfert dans Tensor2Tensor :

class TransferLearningModel(tf.keras.Model):

  def __init__(self, pretrained_model):
    super(TransferLearningModel, self).__init__()
    self.pretrained_model = pretrained_model

  def call(self, inputs):
    return self.pretrained_model(inputs)

def transfer_learning(pretrained_model, new_dataset):
  model = TransferLearningModel(pretrained_model)

  model.compile(optimizer='adam',
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                metrics=['accuracy'])

  model.fit(new_dataset, epochs=10)

  return model

C'est suffisant pour fonctionner tel quel ?

Non, ce code ne suffit pas pour fonctionner tel quel. Il faut encore ajouter du code pour définir le modèle pré-entraîné, l'optimiseur à utiliser et les métriques dont le modèle a besoin pour s'entraîner. Il faut également ajouter des lignes de code pour charger les données d'entraînement et pour tester le modèle sur des données de test.

fait le.

Voici un exemple de code complet pour le module d'apprentissage par transfert dans Tensor2Tensor:

class TransferLearningModel(tf.keras.Model):

  def __init__(self, pretrained_model):
    super(TransferLearningModel, self).__init__()
    self.pretrained_model = pretrained_model

  def call(self, inputs):
    return self.pretrained_model(inputs)

def transfer_learning(pretrained_model, new_dataset):
  model = TransferLearningModel(pretrained_model)

  optimizer = tf.keras.optimizers.Adam()
  loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
  metrics = ['accuracy']

  model.compile(optimizer=optimizer,
                loss=loss,
                metrics=metrics)

  x_train, y_train = new_dataset
  model.fit(x_train, y_train, epochs=10)

  x_test, y_test = new_dataset
  model.evaluate(x_test, y_test)

  return model

c'est suffisant ?

Oui, ceci est suffisant pour fonctionner tel quel. Ce code est complet et comprend toutes les étapes nécessaires à l'entraînement et à l'évaluation du modèle.

montre le code pour utiliser les topics du forum.monnaie-libre.fr comme model. Il s'agit d'un forum Discourse.

Le code suivant montre comment utiliser les topics du forum.monnaie-libre.fr comme modèle dans Tensor2Tensor :

# Charger les topics du forum
forum_topics = discourse.api.get_forum_topics()

# Pré-traiter les données
x, y = preprocess_data(forum_topics)

# Définir le modèle pré-entraîné
pretrained_model = build_pretrained_model(x, y)

# Entraîner le modèle d'apprentissage par transfert
transfer_learning_model = transfer_learning(pretrained_model, (x, y))

# Utiliser le modèle entraîné
results = transfer_learning_model.predict(x)

montre le code de `discourse.api.get_forum_topics()`

Le code suivant montre un exemple de la méthode `discourse.api.get_forum_topics()` :

def get_forum_topics():
  endpoint = 'https://forum.monnaie-libre.fr/c/topics.json'
  response = requests.get(endpoint)
  topics = response.json()

  return topics

Ajoute le contenu de tout stackoverflow au model.

Le code suivant montre comment ajouter le contenu de tout StackOverflow au modèle dans Tensor2Tensor :

# Charger les questions et réponses de StackOverflow
stackoverflow_data = stackoverflow.api.fetch_all_questions_and_answers()

# Pré-traiter les données
x, y = preprocess_data(stackoverflow_data)

# Définir le modèle pré-entraîné
pretrained_model = build_pretrained_model(x, y)

# Entraîner le modèle d'apprentissage par transfert
transfer_learning_model = transfer_learning(pretrained_model, (x, y))

# Utiliser le modèle entraîné
results = transfer_learning_model.predict(x)

Les commentaires sont en Français bien entendu.
Des questions ? (joke)

La blockchain, la monnaie libre et la TRM : comprendre et gérer les risques juridiques et financiers - édition Eyrolles - 2018 - Stéphan Laborde -

Bluffant!! Réponse à tout. Quitte à se créer des faux souvenirs…
Un peu comme un gosse entre 5 et 7 ans :wink:
Mais qui s’est tapé tous les rayons de la bibliothèque qu’on lui a filé !!!

Ca donner envie d’enfermer ces IA dans des dockers pour conserver le mode apprentissage sur des données plus restreintes et précises (Ŋ1 et Ŋ2)

Pour commencer plus simplement que de refaire ChatGPT, un OpenCV, TensorFlow ou PyTorch qui sait décrire ce qu’on lui montre dans une image serait un super service réseau.

On pourrait s’en servir pour aider à cataloguer les objets d’une ressourcerie.
Repérer parmi les photos de nos amis, celles où nous apparaissons.
… Et plein de trucs cool https://thisideadoesnotexist.com/

3 Likes

Autant laisser GPT se recoder en open source.

Je suis tombé sur ça hier. Peut-être que ça peut aider. C’est très bien expliqué.

Je ne parle pas de chatGPT, mais du playground openai.

Il semble meilleur en python que JS et connait toutes les libs, il sais dès maintenant coder entièrement et de zéro sous tes yeux un système équivalent à chatGPT, en python avec libs open sources, en expliquant pas à pas ce qu’il faut améliorer, te le code, et t’ajoute même directement les modèles de données que tu veux en utilisant les libs pythons avec les bonnes API.

Comme je l’ai dit je ne souhaite pas coder ni apprendre à coder ce truc, je veux qu’il le fasse pour nous.

Tout à fait. Mais cette video explique, si je me rappelle bien, comment faire le tchat qui viendra interroger ton playground. J’ai pas tout regardé. J’ai noté cette ressource dans un coin de ma tête, juste au cas où.

Oui c’est déjà fait.

1 Like

https://duniter.org/organic-monetary-system/


Si la personne qui nourrit le réseau de neurones fait des fautes de grammaire (l’avenue au lieu de la venue), l’IA peut-elle devenir le cancre à la table du fond ? :blush:

J’ai craqué et essayez moi aussi chatGPT pour créer un jeu de société original. La problématique est de faire un jeu où les joueurs ne dévoilent leur position sur le plateau que si ils sont dans la ligne de vue d’un adversaire. C’est impossible avec les mécaniques connues actuelles. La seule connue est le jeu en double aveugle. J’ai donc confié à chatGPT la charge de me créer un système inconnu. Il a échoué lamentablement et s’est avéré con comme un balai. C’est moi qui trouvait les idées originales et il ne m’aidait en rien en proposant des mécaniques débiles.

Conclusion, je lui ai donné mon email, mon téléphone (qu’il a vérifié pour les deux) et maintenant je le nourrit pour mon profilage. Vous avez dit que c’était moi le produit ?

De plus, la prétention de chatGPT est de faire une discussion crédible. Mais les fautes de français rendent certaines phrases incompréhensibles et certains mots restent en anglais. Donc la forme est loin d’être du niveau attendu. Le fond est encore pire pour tout ce qui traite des connaissances. Les infos sont fausses ou contradictoires la plupart du temps, ou au mieux des évidences et des lapalissades. On l’a vu ici avec la description de la TRM et de la G1, et de mon côté avec les jeux de sociétés. J’ai aussi posé des questions sur un domaine que je connais mal, mais sachant qu’il peut se tromper souvent, je n’ai aucune confiance dans les infos qu’il me donne…

Par contre il est très fort sur l’analyse de code informatique…!

Je vais suivre attentivement le projet BoG de Librezo qui va peut-être découvrir que les technos d’aide au code existe déjà (pytorch, tensorflow, GPT-2, etc) en libre, sans le côté “chat”. Si on peut ajouter le côté conversation sur des infos correctes, bingo !

Et tes screens semblent le prouver ! Big up à toi et Librezo ! :+1:

3 Likes
1 Like

Avec un ami on l’a testé sur une situation un peu ambigue et interprétable de différentes manières.

Genre, pour tester la solidarité et la promouvoir je me donne un défi de faire un voyage à vélo à 1€/jour.
Pour manger gratuitement dans les restaurants, je viens comme je suis, avec gros sac à dos, une multiprise pour charger mes appareils, des chaussures de marche, explique un peu ma démarche et que je voyage à vélo, et demande juste le pain des barquettes de pain des clients précédents.
Et souvent, je reçois un repas, sans demander.
Au pire je mange dehors des plantes sauvages comestibles (ça pourrait être du pain sans rien ça fait le même effet), et les gens me proposent aussi parfois spontanément des choses.
(il y a une part de vécu, mais j’ai jamais fait le coup du pain dans les restos!)

La machine bloque sur le souci que je contourne les règles des restaurants et cherche à profiter. Idem pour les multiprises.

Je lui dis non mais ça c’est aux USA, ici on est en Europe, les gens font pas ça, c’est vraiment sur le volontariat je ne demande pas grand chose.

Elle continue son blabla, et dit aussi que je peux m’empoisonner avec les plantes sauvages. Je lui explique que j’en suis expert, je les connais mieux que les pharmaciens…

À un moment je lui demande de résumer en 25 mots ce qu’on vient de discuter. Elle juxtapose des éléments marquants de la discussion, ce n’est pas très synthétique.

Je fais un résumé de 10 mots et lui demande si c’est bien.
Ok.

Ensuite je fais un résumé où je me caricature en profiteur qui veut susciter la pitié et qui manipule les gens.
Là quand même, elle me dit que c’est faux, et que c’est pas ce que j’ai dit.

Alors ok, on voit les limites, surtout dans les situations ambigues où il y a des conflits entre plusieurs valeurs ou contraintes.

@vit , @tuxmain

Je sais que ya beaucoup de lecture, vous n’avez pas dû tout lire ici ^^

On ne parle pas du même outil c’est pour ça.
Je ne parle pas de chatGPT qui est un gadget, mais de GPT3.5 qui n’est pas le même model et surtout qui n’a pas les contrôles !

Svp arrêtez de parler de chatGPT et faites connaissance du playground.

Aussi, comprennez qu’une TIA ça se dirige, si elle dit n’imp, c’est votre soucis, pas le siens :wink:

Vérifiez votre température à droite mais jvais pas me répéter 10 fois les gars…

1 Like

Svp ne change pas le titre du sujet de @vincentux qui était chatGPT : …

On ne peut plus donner son avis sur chatGPT dans ce sujet qui lui ait dédié ?
Parce que tu as dévié sur tes expériences dans le playground ?

Dans mon message je te félicite toi et Attilax pour votre travail d’approfondissement des autres outils de OpenAI. Donc de ce que je comprends vous travaillez sur GPT 3.5 (je ne sais pas ce qu’il y a derrière chatGPT). On a bien compris, je crois, que tu ne parles plus de chatGPT.

Mais le sujet du titre c’est chatGPT… Donc il est tout à fait légitime de donner notre expérience et opinion sur chatGPT dans ce sujet. Amha.

3 Likes

Ah pardon, c’est que vue tous les messages j’ai voulu résumé où j’en étais dans mon exploration.

J’ai changé le titre pour être plus général que chatGPT, mais on peut remette chat.

Pas de soucis ! Tu es pardonné (même si je ne te reproche rien hein :blush:)

On peut peut-être créer un sujet dédié à tes recherches sur GPT3.5 et laisser ce sujet sur le chatGPT.

Et qu’en pense @vincentux ? On continue à développer le sujet sur GPT3.5 ici ou on split ?

1 Like

Si vous voulez, mais perso je vais arrêter d’alimenter ces postes ici car on bosses à ce sujet ici: https://chat.librezo.fr/#/room/#gptlibre:yuno.librezo.fr

Car on sort un peu du sujet de Duniter ^^

3 Likes
3 Likes