Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ibjunior/spring-ai-fine-tuning
Ce repos contient le code qui permet de générer les données synthétiques pour le fine-tuning avec OpenAI en utilisant Java et Spring AI.
https://github.com/ibjunior/spring-ai-fine-tuning
generative-ai openai spring spring-ai spring-boot
Last synced: 1 day ago
JSON representation
Ce repos contient le code qui permet de générer les données synthétiques pour le fine-tuning avec OpenAI en utilisant Java et Spring AI.
- Host: GitHub
- URL: https://github.com/ibjunior/spring-ai-fine-tuning
- Owner: IBJunior
- Created: 2024-08-28T11:11:41.000Z (about 1 month ago)
- Default Branch: main
- Last Pushed: 2024-09-03T10:26:13.000Z (24 days ago)
- Last Synced: 2024-09-26T03:42:04.117Z (1 day ago)
- Topics: generative-ai, openai, spring, spring-ai, spring-boot
- Language: Java
- Homepage:
- Size: 214 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Spring AI : Génération des données synthétiques avec OpenAI pour le fine-tuning
Ce repos contient le code qui permet de générer les données synthétiques pour
le [fine-tuning avec OpenAI](https://platform.openai.com/docs/guides/fine-tuning) en utilisant Java et Spring AI.
Les données générées finales seront en fichier [jsonl](https://jsonlines.org/) ressemblant à :
````json lines
{"messages":[{"role":"system","content":"Tu es un assistant qui fournit des informations concises et précises sur\nla compagnie aérienne Fly Intelligent en fonction des requêtes des utilisateurs\n"},{"role":"user","content":"Quelle est la vision de Fly Intelligent pour l'avenir de l'aviation ?"},{"role":"assistant","content":"La vision de Fly Intelligent est de redéfinir l'avenir de l'aviation en intégrant des pratiques durables à tous les niveaux de ses opérations."}]}
{"messages":[{"role":"system","content":"Tu es un assistant qui fournit des informations concises et précises sur\nla compagnie aérienne Fly Intelligent en fonction des requêtes des utilisateurs\n"},{"role":"user","content":"Pourquoi les voyageurs devraient-ils choisir Fly Intelligent ?"},{"role":"assistant","content":"En choisissant Fly Intelligent, les voyageurs peuvent profiter d'une expérience de vol confortable et moderne tout en contribuant à un monde plus durable."}]}
````
## Données de départ
Au départ, on part d'un ensemble de documents PDF (`src/main/resources/documents`) et ensuite pour chaque page du
document PDF, on demande au modèle de
nous générer un nombre de couples (question, réponse) sous le format `jsonl` ci-dessus
confère `src/main/resources/fine-tuning-prompt-template.st` pour voir les détails du prompt.
## Dépendances
* OpenAI (une clé API est nécessaire)
````xml
org.springframework.ai
spring-ai-openai-spring-boot-starter
````
* PDF Document Reader pour extraire les contenus des documents PDF
````xml
org.springframework.ai
spring-ai-pdf-document-reader
````
* Gson pour convertir les objets java en json
````xml
com.google.code.gson
gson
2.11.0
````
* Et cette dépendance que j'ai trouvée qui permet de calculer le nombre de tokens d'un prompt. Avant d'envoyer le prompt
au
modèle, on doit se rassurer de ne pas dépasser le nombre maximal token.
````xml
com.knuddels
jtokkit
1.1.0
````
## Structure du projet
### Conversation
La Classe Conversation représente une conversation une ligne du jsonl final, avec le message utilisateur, système et
assistant.
````java
public class Conversation {
private List messages;
//Getters and Setters
//...
public static class Message {
private String role;
private String content;
//Getters and Setters
}
}
````
### FineTuningDataService
Ce service permet d'appeler le modèle pour chaque page de document pour générer les questions à utiliser pour faire le
fine-tuning.
````java
@Service
public class FineTuningDataService {
//code
public List getConversations() throws InterruptedException {
//Code...
PromptTemplate promptTemplate = new PromptTemplate(promptResource);
for (Document document : documents) {
Prompt prompt = promptTemplate.create(
Map.of("numberOfConversation", "6",
"textPassage", document.getContent())
);
//code...
String content = this.chatClient
.prompt(prompt)
.call()
.content();
//code...
}
return allConversations;
}
//code
}
````
### FineTuningDataCreator
Appelle `FineTuningDataService`, ensuite enregistre les données dans le fichier `jsonl`
````java
@Service
public class FineTuningDataCreator {
//code...
public void run() throws InterruptedException {
log.info("Creating synthetic data started...");
List conversations = fineTuningDataService.getConversations();
Gson gson = new GsonBuilder().disableHtmlEscaping().create();
for (Conversation conversation : conversations) {
String json = gson.toJson(conversation);
writeToJsonFile(json.getBytes(StandardCharsets.UTF_8));
}
log.info("Created {} conversations", conversations.size());
log.info("Creating synthetic data ended...");
}
//code...
}
````
## Fine-Tuning sur OpenAI
Pour faire le fine-tuning sur OpenAI, on a deux choix, soit le faire par code ou en utilisant le dashboard web.
Pour cet exemple, j'ai utilisé le dashboard.
### Choix du modèle et upload du fichier jsonl
Pour cet exemple, ça sera le fichier `src/main/resources/jsons/fly-intelligent-fine-tuning-data.jsonl` et le modèle sera
gpt-4o-mini.
En fait, vous pouvez choisir n'importe quel modèle. Il faut juste qu'il soit différent du modèle utilisé pour la génération
des données. Sinon la performance risque de ne pas être au rendez-vous.
### Test du modèle sur le playground
Après l'upload et le choix du modèle, suivez les instructions jusqu'au lancement du fine-tuning. Une fois que c'est
terminé, vous recevrez une notification.
Vous pouvez alors tester le nouveau modèle sur le playground. Comme suit :
## Contact
Si vous avez des questions spécifiques, n'hésitez pas à me contacter
sur [LinkedIn](https://www.linkedin.com/in/ali-ibrahim-junior/).