Quand tu crées ton propre jeu vidéo : ce que tu t'imagines VS la réalité
1 juin 2017 à 10h46 dans Insolite
Créer un jeu vidéo n'est pas forcément aussi simple que l'on pourrait l'imaginer, loin de là ! Un artiste nous illustre la conception du jeu jusqu'à sa finition, la différence entre ce qu'il se passe dans l'imaginaire des gens et ce qu'il se passe en réalité. De toute évidence, il y a de quoi s'en arracher les cheveux !
avant : "Oh putain, ça à l'air trop compliqué de créer son jeu.. c++, bibliothèques, collisions.."
après : "Oh ben.. Pas besoin de s'y connaître en fait, unreal engine, unity.. nous permet de faire tout ça sans pisser du code ! Je vais revendre mon bouquin sur la théorie des collisions alors !"
Dédicace aux jean-codeurs qui se prennent pour des pros ;)
Aller retourne sur open classroom alimenter le cliché des "développeurs de jeux indépendants" :rire:
L'humour c'est drôle quand c'est de l'humour, pas quand c'est un déversoir de merde comme tu l'as fait
Jsais pas t'as l'air aigri envers les gens qui font ça, mais garde ta rage au lieu de te ridiculiser comme ça en essayant de te rattraper en disant "c'est de l'humour lol".
C'est comme si je disais que t'étais une pure merde et un cancer pour la société, puis que je rajoutais un "mdr lol jrigolais tu connais pas l'humour ou quoi"
Bref j'ai écris ça parce que j'en ai juste marre des gens comme toi sur internet
Encore un qui devrait utiliser el famoso mouchoir pour essuyer mes traces de spermes sur le visage de sa mère en PLS :rire:
Sinon, je m'y connais vite fait en dev de jeu (plus que toi en tout cas hein ?), et je peux t'affirmer que les collisions de bases de moteurs sont géniales ... mais basiques è_è. S'tu veut faire un truc un peu élaboré et personnel (histoire de pas refaire Mario), bah tu remplace toutes les fonctions de bases par celles que t'as faites.
Et pour l'amour de dieu, placer :rire: avec une "blague" de nique ta mère, c'est nul à chier, pas besoin d'être un mouton pour le comprendre
Le petit soucis, c'est justement les gens comme toi qui pensent plus s'y connaître que tout le monde parce qu'il fait du ue4 :rire:
Non je vais très bien, je troll juste une communauté de moutons :hap:
Perso, je ne suis pas du tout dans le jeu vidéo, j'ai fais du dev web au début, ensuite je me suis intéressé au jeu vidéo et là je risque de faire une thèse sur les intelligence artificielles ( pour simplifier sinon personne comprendrait ptdrrrrrrrrr ) donc des programmes qui marchent, j'en ai fait :hap:
( no fake en plus :rire: )
Par contre en nous traitant de moutons, j'estime au moins avoir le privilège que notre auguste seigneur en développement d'IA nous explique ce sur quoi il travail, parce que une thèse sur un bot de morpion ça compte pas
Donc voilà, je travaille sur les réseaux de neurones plus particulièrement. Càd qu'en fait tu crées différentes couches de neurones que tu relis afin d'avoir certains résultats en fonction de certains évênements.
Un "neurone", qu'on appellera "perceptron" ici, est constitué de plusieurs choses, un poids d'entré pour chaque valeur d'entrée et une valeur stockée. Cette valeur stockée est la somme des valeur d'entrées par le poids correspondant. Cette somme doit être passée dans une fonction d'activation afin d'avoir une valeur stockée bornée qui tendra ( pas obligatoirement ) toujours vers ses bornes.
Les couches sont en fait des ensembles de perceptrons à travers lesquelles une information passe afin d'être traité. càd qu'il y a une couche d'entrée, donc plein de perceptrons qui attendent une information et dès qu'ils l'ont il font passer l'info aux perceptrons de la couche d'après et ainsi de suite jusqu'à arriver à la couche finale.
Le truc c'est par exemple, si tu fais un réseau qui doit apprendre la porte ET par exemple, au début au lieu de te sortir 0 ou 1 quand il faut avoir 0 ou 1, il te sortir complètement autre chose.
Donc en gros, ton réseau tu lui donnes des entrées il te donne un résultat et en fonction de son erreur tu changes les poids ( grosso modo ) pour que le coup d'après il soit plus proche de la bonne réponse.
Mais là intervient ce qu'on appelle un algorithme génétique, là c'est justement une grande partie du travail que je prépare. Tes réseaux auront un comportement différents, donc dès qu'ils te donnent un résultat tu dois évaluer à quel point il est différent de ce à quoi tu t'attendais. Mais le problème est : Quelle est la meilleure façon d'évaluer et de sélectionner les meilleurs spécimens de réseaux afin d'avoir le meilleur rendement possible.
Les applications de réseaux comme ça sont très diverses, l'an dernier avec un ami, on en a fait un qui jouait à la bataille navale, et là on travaille sur de la reconnaissance de dessin. On peut aussi en faire un qui apprend à conduire une voiture.
C'est vraiment super passionnant mais très complexe, pour simplifier mes explications j'ai zappé pleins de détails, notamment quel type de réseau, le fait que j'utilise la descente du gradient pour l'apprentissage...
Voilà voilà :hap:
Si tu veux que je parle code on peut aussi :hap:
descente du gradient => apprentissage d'UN SEUL réseau
algo génétique => sélection des meilleurs cas de la génération n pour la génération n+1
:hap:
Et franchement les troll ça devient lourd c'est même plus drôle et ça devient méchant
Mais qui se confronte à une communauté pseudo-geek, t'es sur Hitek, t'étonnes pas si les mecs te foutent des poce rog ;o
(J'attends les miens du coup pour avoir insulté la communauté svp <3)
j'ai le droit de dire ce que je veux :hap:
De l'amour et du respect ne fait de mal à personne, au contraire !
J'ai déjà lu sur le sujet et ce qu'il dit semble être que du plagiat.
Maintenant c'est l'heure des petites précisions, parce que je pense que tu t'es trompée de personne en parlant d'un "sale puceau" :rire:
Je n'ai évoqué que le domaine de mon travail, bien sûr que non je vais dévoiler mes résultats directement à des random comme vous. Donc forcément vu que les réseaux de neurones ne sont pas nouveau vous avez surement déjà vu un article dessus.
Je ne suis pas encore en doctorat donc c'est normal que ce ne soit qu'un "travail personnel" et c'est aussi pour ça que j'ai décidé de ne pas encore partager mon travail parce que je veux être le seul et unique auteur de mes résultats. Et pas partager la "pseudo-gloire" avec d'autres mecs qui n'ont faits que rajouter un point-virgule sur mon github.
Donc les rageux continuez à rager ça me fait plus rire qu'autre chose :rire:
Et les autres, j'ai juré sur mon honneur que c'était vrai et non pas du plagiat et effectivement, je n'ai rien copié du tout et ai seulement utilisé mon cerveau. Maintenant si vous vous attendez à des choses nouvelles qui ne sont jamais sortis de nul part, il faudra attendre mes résultats. Sachant que ça risque de prendre encore du temps. Mais en attendant mes articles feront très bien l'affaire.
Sinon je vais vous prouver que je n'ai rien plagié en partageant avec vous une partie de ma classe de réseau de neurones ainsi qu'une implémentation de méthode liée. Cherchez pas, c'est moi qui l'ai inventé :hap:
typedef struct{
double value;
double *weights;
}neurone;
class NeuralNetwork
{
private :
neurone *_input;
neurone **_hidden;
neurone *_output;
double *_deltaInput;
double **_deltaHidden;
double *_deltaOutput;
double _alpha;
int _nbInput;
int _nbHiddenLayers;
int *_nbHiddenNeurons;
int _nbOutput;
public :
double sigmoid(double x);
double arctan(double x){return atan(x);};
...
méthode :
void NeuralNetwork::retroPropagation(double *result, double (*df)(double)){
int i, j ,k;
double sum;
//OUTPUT DELTA
for(i=0;i<_nbOutput;i++){
//cout<<"Delta output : "<<result[i] - _output[i].value<<endl;
_deltaOutput[i] = result[i] - _output[i].value;
}
//HIDDEN DELTA
//First hidden delta layer calculation
for(i=0;i<_nbHiddenNeurons[_nbHiddenLayers-1];i++){
sum=0;
for(j=0;j<_nbOutput;j++){
// cout<<_hidden[_nbHiddenLayers-1][i].weights[j]<<" x "<<_deltaOutput[j]<<endl;
sum+=_hidden[_nbHiddenLayers-1][i].weights[j]*_deltaOutput[j];
}
// cout<<_hidden[_nbHiddenLayers-1][i].value<<endl;
// cout<<sigmoid(_hidden[_nbHiddenLayers-1][i].value)<<" x "<<sigmoid(1-_hidden[_nbHiddenLayers-1][i].value)<<" x "<<sum<<endl;
_deltaHidden[_nbHiddenLayers-1][i] = df(_hidden[_nbHiddenLayers-1][i].value)*sum;
}
//Others hidden delta layers
for(i=_nbHiddenLayers-2;i>=0;i--){
for(j=0;j<_nbHiddenNeurons[i];j++){
sum=0;
for(k=0;k<_nbHiddenNeurons[i+1];k++){
sum+=_hidden[i][j].weights[k]*_deltaHidden[i+1][k];
}
_deltaHidden[i][j] = df(_hidden[i][j].value)*sum;
}
}
}
ALLER BISOUS LES VIERGES !
la preuve, c'est mon pseudo "MrBeauf" banni d'ailleurs.. Mettez "rip" si vous aussi vous trouvez ça triste :rire:
Si tu cherchais à comprendre le code tu comprendrai rapidement que c'est pas que des simples "tableaux" :rire: que je remplis !
Tu vois, c'est ce que je reproche aux filières en deux ans en info c'est que vous ne savez rien faire. On a tellement voulu vous faire apprendre de choses en 2 ans qu'au final vous n'avez rien appris. Vous savez pas faire la différence entre alloc dynamique et alloc statique, vous savez pas faire la différence entre récursivité terminale et non terminale ( si vous savez ce qu'est la récursivité :rire: ). Et c'est justement à cause de ça que j'ai jamais vu un mec d'IUT dans les top 5 de ma promo ( enfin.. il y avait 4 places puisque j'y suis moi même ).
Montre ce code à tes profs et ils te diront tous que c'est une très bonne implémentation d'une descente de gradient en c++ ( c'est du code que j'ai pondu moi même pas la peine de chercher ailleurs ). La complexité asymptotique en O(n²) en fait une implémentation assez efficace surtout en espace mémoire puisqu'il n'y a d'alloué que le strict minimum.
Ensuite, si tu étais si renseigné que ça, tu saurais que les intelligences artificielles, côté bas niveau. C'est comme ça que c'est foutu. J'ai utilisé ce code pour faire apprendre à jouer un bot à la bataille navale, là avec un pote on fait de la reconnaissance de dessin et ensuite, soit on fera une IA ( peut être pas un ANN ) qui composera de la musique soit une IA qui saura décrire ce qu'il voit sur une image avant de passer à du temps réel.
Tu sais, je suis quelqu'un de très égocentrique. Mais quand quelqu'un surpasse mon niveau ou est meilleur que moi, je sais l'admettre alors maintenant plus la peine de chercher plus loin je vous ai prouvé que j'étais pas un RSAiste mais un VRAI informaticien. Donc la seule chose que vous pouvez faire c'est fermer votre gueule. :hap:
Louis.
Oui voilà j'alloue directement la mémoire pour chaque perceptron ce qui me permet de ne pas faire de calculs inutiles. Sur python c'est très simple de faire un réseau, il suffit de faire du calcul matriciel sauf que tous les 0 de la matrices seront quand même calculés or dans mon code non puisqu'il n'y a pas de 0 :hap:
Ensuite qu'est ce que tu entends par débordement ? De la pile ? Ou des tableaux ? Pour la pile je n'utilise pas de récursivité donc aucun risques et pour les tableaux dans ma classe je stock le nombre de neurones par layer et le nombre de couche caché ainsi que chaque nombre de neurones dans les couches cachées et j'utilise ces nombres dans mes boucles. Ces nombres sont les seules entrées du constructeur qui se débrouille avec :hap:
Ahah je t'avoue que j'ai galéré avec ce cas parce qu'il y avait plein de façons de le régler, j'ai tout simplement fait les traitements sur les couches cachées en deux parties, d'abord première couche cachée à traiter et ensuite le reste s'il y en a. Exemple : avec ma propagation de valeurs la première couche cachée et ensuite les autres s'il y en a. Avec ma rétropropagation et mise à jour, c'est la dernière couche cahcée et le reste s'il y en a.
J'avoue qu'il doit certainement il y avoir mieux notamment en utilisant les propriétés des sous-matrices mais le calcul matriciel étant très coûteux j'ai préféré faire différemment.
J'anticipe un peu mais on m'a déjà posé la question, de pourquoi j'ai pas utilisé d'objet vector. Pour plusieurs raisons. Si je dois faire un réseau en 3 dimensions, ce sera plus simple d'adapter mon code puisque je n'aurai qu'à fournir un pointeur de plus. Pour rester sur les pointeurs, vu que c'est qu'une adresse mémoire ça ne prend que très peu de place en mémoire et ne pas utiliser vector me permet d'utiliser que très peu de ressources d'autant plus que je n'utilise pas d'iterator. Ce qui est assez efficace quand j'utilise le réseau en temps réel par exemple, faire un réseau qui apprend en se déplaçant et lorsqu'il meurt après avoir appris il fait naître un autre réseau ayant les poids initialisés à son prédécesseur + une marge aléatoire en fonction du nombre de générations.
Voilà voilà :hap:
Va chercher du travail plutôt que te ridiculiser sur internet :rire:
Oui tout ce que j'ai marqué ci dessus est vrai, malheureusement je n'ai pas ton adresse mail ( il n'est dispo que pour hitek je pense ). Je vais pas tarder à sortir un article de "vulgarisation" de différents types d'intelligences artificiels notamment utilisant le concept de deep learning ( qui apprend tout seul en gros ).
Mais c'est déjà sympa de connaitres ces deux langages. De toute façon on peut pas passer à côté si on veut faire du dev web :)