> Je pense que c'est bon, on a le cadre théorique, tout, du coup on va pouvoir s'y remettre, sur notre projet !

> "Le projet" ?

> Celui de faire le programme qui rédige des livres tout seul ?

> Ouais c'est ça, on y est presque, et la avec la nouvelle technique, ça devrait marcher...

> C'est quoi le principe ?

> Ben c'est simple, t'imagine l'ensemble des histoires possibles F qu'on peut faire et l'ensemble des suites de mots possibles E, on sait que E est inclus dans F car toute histoire est une suite de mots.

> Oui on en avait déjà discuté, c'est le cadre conceptuel. Et donc ?

> Réaliser une machine qui arrive à écrire une histoire, on peut voir ça formellement comme étant une procédure qui donne en sorte un élément de E, donc une suite de mots, dont on sait qu'elle appartient à F, c'est-à-dire que la suite de mots a un sens.

> Ouaip, mais on part pas de 0, il y a déjà des tas et des tas de textes qu'on a pu récolter sur Internet, un petit millier de To, c'est ça ?

> Ouais plus exactement 1 654 To, ça fait une bonne quantité !

FichierDonnees = Fichier.Nouveau(adresse = "D://donnees/donneesTexte.bdt", lecture = vrai) ;;

Donnees.chargement(initialisation = vrai, fichier = FichierDonnees) ;;

[...]

> Sur le principe, je suppose qu'on fait pas le truc classique, l'apprentissage profond ?

> En fait on un nombre de données d'entrée irrégulier, donc ça va pas marcher

> Mais on peut quand même les rééchelonner, et moyenner pour obtenir les fréquences d'éléments de base, ça devrait être utile de décomposer à un premier niveau

> Hum ... Moi je conseillerais plutôt d'avoir un nombre de variable fixe, et de faire passer la grille sur des n-uplets.

> Pas bête... Mais ça règle pas le problème, on va toujours avoir une quantité de données dépendant du texte considéré.

> Une solution, ce serait de couper en plusieurs catégories, séparer les petits textes d'un côté, on leur fait une classification, genre le truc de base linéaire + du plus évolué quitte à re-traiter par la suite.

> Et pour les gros ?

> On les coupe en blocs, et on applique l'analyse sur chacun des blocs, on les projette dans une bonne base, genre Fourier, et on prend les p premières composantes.

seuil1 = 3000 ;;

TextesCourts = FichierDonnees[fichier: où(fichier.longueur <= seuil1 )] ;;

resultatClassif = faireClassif(donnees = TextesCourts, linéaire = vrai, max_iteration = 500, alpha = 0.6) ;;

TextesRestants = FichierDonnees[fichier: où(fichier.longueur > seuil1 )] ;;

// Début de la boucle pour traiter les fichiers

ListeParties = [ ] ;;

PourChaque fichier_iter dans TextesRestants faire:

{

n_parties = ent(fichier_iter.longueur / seuil1) ;;

Parties_iter = fichier_iter.decoupeTexte(nombreParties = n_parties) ;;

ListeParties.ajoute(Parties_iter) ;;

}

[...]

> Et une fois qu'on a extrait les caractéristiques de la base, on en fait quoi ?

> On est aux caractéristiques bas-niveau, les informations parties par parties. Mais maintenant on va devoir s'attaquer à un truc plus dur, le squelette de l'histoire... On pourrait le faire en paramétrique, mais je pense que c'est pas une bonne idée.

> Ouais, ce serait pas assez flexible pour absorber toute la structure.

> Du coup, c'est là où on pourrait réutiliser les réseaux de neurones ?

> Ouais, un petit devrait faire l'affaire, je dirais 7 couches d'épaisseur, avec une largeur du type 1x10x50x200x200x1000x200 ?

> Je pense que la couche de fin est pas suffisante. Mon idée : 1x10x50x200x200x1000x200x150x150

> Ok, de toute façon on pourra tester les deux et garder la meilleure.

listeCouches1 = [ 1, 10, 50, 200, 200, 1000, 200, 150, 150 ] ;;

reseauNeurones1 = ReseauNeurones.nouveau(couches = listeCouches1) ;;

theta_apprentissage = 0.1 ;;

Nombre_iter = 10^6 ;;

commencerApprentissage(reseau = reseauNeurones1 , theta = theta_apprentissage, iterations = Nombre_iter) ;;

[...]

> Pas possible ! Dans chacun des tests on est bloqués !

> Qu'y a-t-il ?

> L'algo converge pas ! Enfin, pour chaque structure, ça marche pas, on doit pas avoir le bon theta de Newton. Les thetas trop petits, ils nous donneraient peut-être la convergence, mais en 10^5 années à ce stade, et les theta trop grands font un algo totalement instable, les coeff sautent de partout...

> Vous avez essayé de rajouter une pénalisation, genre comme dans le recuit simulé ?

> C'est-à-dire ?

> Avec un truc qui dépendrait du temps, pour arriver à un truc stable.

> Ouaip... Ou alors on pourrait changer l'algo de propagation et prendre theta = theta(t), genre décroissant lentement ?

> Faudrait alors choisir une forme fonctionnelle pour la dépendance en t... Vous pensez à un truc exponentiel ?

> Ouais, mais genre par morceaux, avec des pas de taille croissante

> Du coup pas d'exponentielle, on peut faire les grilles classiques.

listeThetas = [50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01] ;;

PourChaque i dans (1:Nombre_iter) faire :

{

theta_apprentissage = choixTheta(ind = i, thetas = listeThetas) ;;

commencerApprentissage(reseau = reseauNeurones1 , theta = theta_apprentissage, iterations = 20) ;;

}

[...]

> Et maintenant ?

> Vous avez réussi à faire converger les algos ?

> Ouais, ça devrait être bien significatif... Peut-être même un peu de sur-apprentissage

> Faudrait voir ça... Ça passe les tests de validation croisée ?

> Oui, mais pas de beaucoup, il y a un risque qu'on ait des coeff inutiles, on pourrait vérifier ça en faisant du ré-échantillonnage

> Nonparamétrique ?

> Forcément...

> Il n'y a plus qu'à lancer les simus, alors !

nombreSimulations = 100 ;;

PourChaque i dans (1:nombreSimulations) faire :

{

simulation1 = reseauNeurones1.faireSimulation() ;;

stockerSimu(simulation = simulation1, emplacement = i) ;;

}

[...]

> Vous avez vu les résultats ?

> Vous voulez dire "lu", plutôt, comme c'est un texte ?

> Oui oui. Alors, vos avis ?

> Ben, franchement, c'est pas mal, il reste un peu de calibration à faire, mais ça semble cool.

> Je pense qu'il y a vraiment du potentiel, ça ressemble bien à ce que je l'ai l'habitude de lire... Je dirais même que c'est difficilement distinguable !

> Tant que ça ?

> Ben... On est forcément influencés par nos propres biais. Une façon d'en être certain, ce serait de connecter directement la sortie de l'algo avec un site de publication.

> Hum ... Ce serait une super idée, oui !

> Et à après tout on a rien à perdre, il suffirait de prendre un pseudo, et puis on verra bien si les gens s'en rendent compte ou non.

> On pourrait même devenir riches, si beaucoup de gens l'achètent !

> Ne rêvez pas trop non plus. Si on veut réussir à faire écrire le premier récit inventé par une machine, il faut que ce soit elle à 100% qui s'en occupe. Donc on ne doit pas la lire avant de la publier.

> Il faudrait même écrire un programme qui choisit automatiquement un titre et qui rédige un résumé...

[...]

> Tu sais quoi ?

> Non ?

> On vient de recevoir un message de la part du site, là , celui où on avait mis le truc écrit en sortie du programme.

> Ok, et donc ? Ils ont vu que c'était nul ?

> Non, justement, c'est le contraire ! On est numéro 1 des ventes sur la semaine, apparemment ça a beaucoup plu !

> Tu te moques de nous ?

> Enfin ça devrait être bien possible, vu qu'on a fait une pondération via le classement...

> Attendez, je vous transfère le mail !

> Eh ouais, effectivement !

> Du coup on leur répond quoi ?

> Je sais pas ...