Le topic de la programmation, string, chaînes, cuir et compagnie

[Raplonu]

Le papier : http://vcl.ece.ucdavis.edu/pubs/2016...p.kiloCore.pdf

Faut voir en pratique, là c'est un peu maigre en information.

[Møgluglu]

1 page + figures, c'est normal, c'est le format des confs de technos et circuits (l'ISSCC c'est pareil). C'est plus un extended abstract avec des figures. Ils ont des centaines de papiers dans leur programme aussi.

Pendant ce temps à ISCA, conf d'archi, on ne parle plus que de processeurs dédiés au deep learning et autres accélérateurs neuromorphiques. Les many-core, c'est totalement has-been.

Pour ce qui est du calculateur chinois, si c'est juste pour continuer dans le simple concours de bite, autant s'abstenir (pour info, en Europe, on vise l'exascale (En fait, il s'agit de faire du peta scalable en exa) ).

Continuer le concours de bite implique développer un processeur pour le HPC au niveau de Pascal et Knights Landing, à la mémoire HBM près. C'était assez inattendu.

Encore faut il savoir quoi en faire de ces machines là. Là ou je bosse, on fait du HPC mais c'est vraiment pas notre cœur de recherche, pourtant on a accès à une des machines du top 10 et une autre presque dans le top 100. Les gens avec qui on est en contact sont en général super contant d'avoir "enfin" des calcules à faire...

On peut avoir des heures sur Curie sans trop de difficulté, mais faut une propal un peu sérieuse pour avoir tout le supercalculateur pour soi tout seul. (Enfin ça fait longtemps qu'il a décroché du top 10.)

[vectra]

Pendant ce temps à ISCA, conf d'archi, on ne parle plus que de processeurs dédiés au deep learning et autres accélérateurs neuromorphiques. Les many-core, c'est totalement has-been.

Pourtant, c'est ce qui sera le plus utile.

[Lazyjoe]

Pour l'instant, dans les vrais cas de la vraie vie on est déjà content si on arrive à tourner aussi vite sur un xeon phi.... que sur un xeon bi-socket.

[vectra]

Non.
Parce que

[ds108j]

Y a-il des pros de la désobfuscation de code Javascript ? J'ai besoin d'aide sur le décorticage d'un code (et mettre des document write ne m'a pas aidé).

Attention ! Ne pas lancer le code, c'est un downloader pour un Ransomware !!!!!

Edit : Je préfère vous l'envoyer en MP pour ceux qui pourraient m'aider, ça évitera les infections indésirables

[Tramb]

Il existe du code js non obfusqué ?

[vectra]

Il existe du code js ?

[Nattefrost]

Oui j'ai entendu parler de compteurs de clics.

[Metalink]

Hello, j'ai enfin une occasion de poster dans ce topic

En effet, j'ai un travail à rendre (alors que je suis en vacances) et j'aurais bien besoin d'aide : je dois réaliser une IA pour un Pacman (le machin jaune qui mange des gommes) et ... j'ai pas la moindre idée de par où commencer, étant donné que les "cours" d'IA qu'on a eu ressemblaient plus à des discussions et des démonstrations de technologies. En gros j'ai un petit moteur maison qui fait tourner un Pacman, dans lequel je balance un script en Lua dans lequel je suis censé coder mon IA justement.

Donc si vous avez un peu des pistes sur comment organiser des idées, quels genre d'algo je pourrais utiliser, ou même des trucs tout bête pour m'aider à commencer, ça serait top
Et sinon je continuerais sur ma lancée de "si ya des gommes à droite, on continue vers la droite"

[Møgluglu]

Commence par construire une structure de données qui représente une configuration du jeu. Puis des fonctions de transition qui permettent de passer d'une configuration à l'autre en fonction des actions du joueur et des fantômes. Après, tu n'as plus qu'à utiliser des heuristiques qui vont bien pour explorer le graphe des configurations possibles (brute-force est un bon départ ).

[Max_well]

Hello, j'ai enfin une occasion de poster dans ce topic

En effet, j'ai un travail à rendre (alors que je suis en vacances) et j'aurais bien besoin d'aide : je dois réaliser une IA pour un Pacman (le machin jaune qui mange des gommes) et ... j'ai pas la moindre idée de par où commencer, étant donné que les "cours" d'IA qu'on a eu ressemblaient plus à des discussions et des démonstrations de technologies. En gros j'ai un petit moteur maison qui fait tourner un Pacman, dans lequel je balance un script en Lua dans lequel je suis censé coder mon IA justement.

Donc si vous avez un peu des pistes sur comment organiser des idées, quels genre d'algo je pourrais utiliser, ou même des trucs tout bête pour m'aider à commencer, ça serait top
Et sinon je continuerais sur ma lancée de "si ya des gommes à droite, on continue vers la droite"

Globalement ça dépend des informations que t'as lors du déroulé du jeu.
Commence simple ("si ya des gommes à droite, on continue vers la droite"), puis rajoute des subtilités au fur et à mesure ("si ya des ghost à droite, on continue vers la gauche") et tu devrait arriver à un truc potable.

Si t'as la vision sur tout le plateau, et que c'est les comportements standards du pacman (chaque ghost à un algo simple et fixe), tu peux réussir à coder un truc qui peux quasi jamais perdre.
Si tu veux t’entraîner à ce genre de chose et que t'as le temps, viens sur le topic codinggame, et fait des challenges ou IA (http://forum.canardpc.com/threads/10...step-dans-l-OP).

[Monsieur Odd]

Il existe du code js ?

Rigole, dans 78 ans et l'es 132 le JS sera le nouveau CPP !1!1§

[Metalink]

Déjà merci pour les réponses Et codingame je glandais un peu dessus l'année dernière c'est chouette, j'avoue que je devrais profiter de l'été pour m'y remettre un peu sérieusement !

Ce que tu proposes ressemble ce que je pensais faire "à ma sauce" dans un premier temps, mais en ayant discuté un peu avec quelques potes qui s'y connaissent j'ai vaguement des idées de ce que je vais faire, et je pense commencer par essayer d'implémenter un BFS demain (sans prendre en compte les fantômes dans un premier temps) et voir ce que ça donne (et la façon dont je me sers des données).

[Max_well]

Si t'es en données ouvertes, tu peux le faire en brute force, en 'simulant' les tours suivant pour chaque coup que tu peux faire à un tour donnée.
Selon le temps que tu as entre chaque tour, tu peux simuler 5 à 10 tours d'avance, en prenant le meilleur coup à chaque fois (celui où tu meurt pas )

[Janer]

On m'a suggéré de poser la question ici !

Je manipule énormément de données et ça me pose des problème de RAM, même avec la mémoire virtuelle, j'ai pas envie de rentrer dans une grosse machinerie avec des méthodes genre HDF ou une base de donnée SQL car je pense que ce n'est pas nécessaire.

En fait mon tableau de donnée est gigantesque (2 000 000 de lignes et 1000 colonnes) mais il y a beaucoup de redondance, entre deux lignes, les attributs dans les colonnes qui changent sont souvent peu nombreux. Par exemple en général il y a des dizaines de milliers de lignes qui concernent une même station et donc ont plus de 1000 attributs qui représentent des données spatiales qui sont identitiques, seul la date de la mesure et quelques autres données vont différer. J'ai donc en rentrant les données dans des classes pu gagner beaucoup d'espace (genre une classe qui représente la station et les nombreuses données "statiques", une sous classe qui représente la mesure et ses changements etc...)

Le problème c'est que les outils statistiques demandent en entrée non pas des objets mais des tableaux 2D. Mon idée, je pense que c'est possible c'est d'interfacer mon objet qui économise la mémoire avec un tableau classique. En gros un moyen de faire une interface qu'on va appeler du genre data[i][j] et pouvoir expliquer comment cette requête va aller chercher les informations dans mes objets... Et interfacer ça tranquillement avec les bibliothèques de data habituel.


En vrai il y a 45 objects avec 1000 attributs. Donc 45 lignes et 1000 colonnes.

Et pour chacun de ces objets il y a 3-4 attributs qui ont évolué sur la période de mesure, donc 3-4 colonnes et 2 000 000 de lignes.

Mais même en terme de stockage ça me ferait chier de générer un fichier de telle taille. Cela fait autant de lignes et de colonnes "virtuellement", mais en fait la quantité de donnée réelle, l'information réelle est beaucoup plus petite.

Je vais poser mon problème autrement : imagine que j'ai une matrice très creuse, mais genre super creuse, avec des zéros partout sauf pour 1/1000 des valeurs et que je sais où sont les 0 (du genre je pourrais faire une faction qui avec i la ligne et j la colonne déterminerait si c'est un 0 ou si il faut vraiment regarder la valeur). Un module de statistique standard me demanderait un bête tableau 2d et je serais obligé de générer un énorme fichier 1000 fois trop grand pour ça, alors qu'il est plein de zéros! Du coup j'aimerais savoir s'il était possible de créer un "faux tableau" pour l'interfacer avec les modules standards, qui quand on appelle data[i][j] vérifie d'abord si c'est pas un zéro car ça couvre 99,99% des cas, puis si ce n'est pas le cas va chercher dans un container plus petit la donnée voulue!

En fait je trouve ça bourrin de construire une base de donnée quand l'information réelle est pas si grosse.

Un problème similaire serait si les données sont générées procéduralement. Je peux pour tout i et tout j obtenir une certaine valeur et je voudrais pouvoir interfacer ce mapping avec une fonction d'un module statistique qui prend en entrée un bête tableau 2d, sans avoir à pré-générer le tableau à l'avance qui peut être gigantesque! Je ne vois pas pourquoi ce ne serait pas possible, après tout c'est tout con un tableau, c'est un truc qui à (i,j) associe une valeur. Evidemment mon tableau virtuel ou procédural sera pas aussi efficace car qu'un vrai tableau qui map des valeurs stockées sur la mémoire de l'ordinateur, mais ça c'est mon problème de rendre ma fonction rapide.

[Dross]

Je n'ai pas vu de questions mais je vais tenter de te donner des inputs sur ce que tu viens de nous décrire :

Ton modèle qui optimise la mémoire ressemble beaucoup à un "Domain Model", et c'est une bonne pratique de développement.
(cf Domain-Driven Design de Eric Evans si tu veux de la lecture)

Ensuite, comme tu le propose déjà, tu devra sans doutes formater ces données pour les donner à d'autres consommateurs, comme ton autre application qui n'accepte que des tableaux. C'est normal et absolument pas aberrant (si c'est la question que tu te pose), après à toi de voir comment tu veux le faire : via un convertisseur, un wrapper, un décorateur, ...

Pour le stockage lui même, si j'ai bien compris l'état de tes données, tu pourrai sans doutes t'inspirer des algos de compression/JPEG pour les enregistrer : au lieux de sauvegarder toutes les valeurs de la matrice de pixels, on sauvegarde juste les coordonnées qui on la même valeur (explication grossière, je ne suis pas du domaine, mais c'est comme ça que ça marche je crois).
Dans ton cas, tu ne sauvegarderai donc que les coordonnées qui ne le sont pas par défaut, avec un mapping vers la valeur en question.

Par exemple :
Table 1 :
Coord[x1,y1] -> clé de la valeur 1
Coord[x2,y2], Coord[x3,y3] -> clé de la valeur 2

Table 2 :
clé de la valeur 1 -> valeur 1
clé de la valeur 2 -> valeur 2

Avec tout le reste initialisé avec les valeurs par défaut.
Après comment ranger ça, ça dépendra de la techno utilisé (sérialisation d'objets ? SQL ? NoSQL ? ...)

[Teocali]

On m'a suggéré de poser la question ici !

Je manipule énormément de données et ça me pose des problème de RAM, même avec la mémoire virtuelle, j'ai pas envie de rentrer dans une grosse machinerie avec des méthodes genre HDF ou une base de donnée SQL car je pense que ce n'est pas nécessaire.

En fait mon tableau de donnée est gigantesque (2 000 000 de lignes et 1000 colonnes) mais il y a beaucoup de redondance, entre deux lignes, les attributs dans les colonnes qui changent sont souvent peu nombreux. Par exemple en général il y a des dizaines de milliers de lignes qui concernent une même station et donc ont plus de 1000 attributs qui représentent des données spatiales qui sont identitiques, seul la date de la mesure et quelques autres données vont différer. J'ai donc en rentrant les données dans des classes pu gagner beaucoup d'espace (genre une classe qui représente la station et les nombreuses données "statiques", une sous classe qui représente la mesure et ses changements etc...)

Le problème c'est que les outils statistiques demandent en entrée non pas des objets mais des tableaux 2D. Mon idée, je pense que c'est possible c'est d'interfacer mon objet qui économise la mémoire avec un tableau classique. En gros un moyen de faire une interface qu'on va appeler du genre data[i][j] et pouvoir expliquer comment cette requête va aller chercher les informations dans mes objets... Et interfacer ça tranquillement avec les bibliothèques de data habituel.


En vrai il y a 45 objects avec 1000 attributs. Donc 45 lignes et 1000 colonnes.

Et pour chacun de ces objets il y a 3-4 attributs qui ont évolué sur la période de mesure, donc 3-4 colonnes et 2 000 000 de lignes.

Mais même en terme de stockage ça me ferait chier de générer un fichier de telle taille. Cela fait autant de lignes et de colonnes "virtuellement", mais en fait la quantité de donnée réelle, l'information réelle est beaucoup plus petite.

Je vais poser mon problème autrement : imagine que j'ai une matrice très creuse, mais genre super creuse, avec des zéros partout sauf pour 1/1000 des valeurs et que je sais où sont les 0 (du genre je pourrais faire une faction qui avec i la ligne et j la colonne déterminerait si c'est un 0 ou si il faut vraiment regarder la valeur). Un module de statistique standard me demanderait un bête tableau 2d et je serais obligé de générer un énorme fichier 1000 fois trop grand pour ça, alors qu'il est plein de zéros! Du coup j'aimerais savoir s'il était possible de créer un "faux tableau" pour l'interfacer avec les modules standards, qui quand on appelle data[i][j] vérifie d'abord si c'est pas un zéro car ça couvre 99,99% des cas, puis si ce n'est pas le cas va chercher dans un container plus petit la donnée voulue!

En fait je trouve ça bourrin de construire une base de donnée quand l'information réelle est pas si grosse.

Un problème similaire serait si les données sont générées procéduralement. Je peux pour tout i et tout j obtenir une certaine valeur et je voudrais pouvoir interfacer ce mapping avec une fonction d'un module statistique qui prend en entrée un bête tableau 2d, sans avoir à pré-générer le tableau à l'avance qui peut être gigantesque! Je ne vois pas pourquoi ce ne serait pas possible, après tout c'est tout con un tableau, c'est un truc qui à (i,j) associe une valeur. Evidemment mon tableau virtuel ou procédural sera pas aussi efficace car qu'un vrai tableau qui map des valeurs stockées sur la mémoire de l'ordinateur, mais ça c'est mon problème de rendre ma fonction rapide.

Pareil que Dross, je suis pas trop sur de ce que tu veux, mais il me semble que ce que tu as développé, c'est un système ORM, comme Object-Relational Mapping. Et le souci que tu rencontres en termes d'optimisation de l'espace, c'est (entre autre) un problème de gestion de l'héritage. Je te conseille de regarder du coté d'Hibernate. C'est un framework Java pour l'ORM. Même si tu n'utilises pas Java, regarder leur différente manières de gérer l'héritage peut te donner des idées

De même, pour ce qui est de ton histoire de "faux tableau", ça ressemble vachtment à une vue SQL : https://fr.wikipedia.org/wiki/Vue_(b..._donn%C3%A9es). A noter que sous certains SGBD, ta vue peut être le résultat d'une procédure stockée.

[Janer]

Je n'ai pas vu de questions mais je vais tenter de te donner des inputs sur ce que tu viens de nous décrire :

Ton modèle qui optimise la mémoire ressemble beaucoup à un "Domain Model", et c'est une bonne pratique de développement.
(cf Domain-Driven Design de Eric Evans si tu veux de la lecture)

Ensuite, comme tu le propose déjà, tu devra sans doutes formater ces données pour les donner à d'autres consommateurs, comme ton autre application qui n'accepte que des tableaux. C'est normal et absolument pas aberrant (si c'est la question que tu te pose), après à toi de voir comment tu veux le faire : via un convertisseur, un wrapper, un décorateur, ...

Pour le stockage lui même, si j'ai bien compris l'état de tes données, tu pourrai sans doutes t'inspirer des algos de compression/JPEG pour les enregistrer : au lieux de sauvegarder toutes les valeurs de la matrice de pixels, on sauvegarde juste les coordonnées qui on la même valeur

[...]

Avec tout le reste initialisé avec les valeurs par défaut.
Après comment ranger ça, ça dépendra de la techno utilisé (sérialisation d'objets ? SQL ? NoSQL ? ...)

Pareil que Dross, je suis pas trop sur de ce que tu veux, mais il me semble que ce que tu as développé, c'est un système ORM, comme Object-Relational Mapping. Et le souci que tu rencontres en termes d'optimisation de l'espace, c'est (entre autre) un problème de gestion de l'héritage. Je te conseille de regarder du coté d'Hibernate. C'est un framework Java pour l'ORM. Même si tu n'utilises pas Java, regarder leur différente manières de gérer l'héritage peut te donner des idées

De même, pour ce qui est de ton histoire de "faux tableau", ça ressemble vachtment à une vue SQL : https://fr.wikipedia.org/wiki/Vue_(b..._donn%C3%A9es). A noter que sous certains SGBD, ta vue peut être le résultat d'une procédure stockée.

Ok les gars, merci déjà pas mal de choses sont plus clairs dans ma tête grâce à vous. Oui en effet c'était plutôt un problème qu'une question. Pour le stockage de donnée je n'ai pas vraiment de problème, je sérialize mes objets qui sont plutôt efficaces et cela me convient, les données en elle-même ne sont utilisées que par moi.


Je vais maintenant être plus précis. Déjà je bosse en python et utilise le module scikit-learn.
Mon vrai problème est de l'utilisation de ces données. Mon module statistique demande un tableau 2D naif, du coup on en revient à mon problème, je dois combiner mes données et je me retrouve un avec un tableau beaucoup trop gros comme je l'ai expliqué plus haut. Donc pour être précis mes données ressemblent à ça :

-45 Stations (lignes) ayant environ 1200 caractéristiques chacune (colonnes)

-Pour chacune de ces stations environ 2 000 000 de mesures (lignes) de 4 données (colonnes).

Le module statistique me demande un tableau numpy (tableau 2d rapide), du coup je dois fusionner les deux tableaux, et pour chacune des 2 000 000 de mesures (lignes), je dois rajouter le millier de caractéristiques de la station dans laquelle a été fait cette mesure pour que ce soit pris en compte dans les calculs. Du coup si je fais ça bêtement, comme indiqué je me retrouve avec un tableau de 2 000 000 de lignes plus de 1000 colonnes.

Du coup, j'aimerais en fait savoir comment interfacer ma façon de stocker les données qui est très économe, avec la fonction statistique. Elle demande un tableau 2D, mais le générer prendrait trop de mémoire pour rien... mais je sais comment, étant donnée i et j retourner data[i][j], de ma structure de donnée très légère, du coup j'ai virtuellement un tableau et cela devrait être possible non? Juste je ne sais absolument pas comment faire pour l'interfacer...

Est-ce que faire une classe qui hérite du tableau est la bonne direction?

[Teocali]

Le module statistique, tu as la main sur le code ?

Edit : je manque de temps pour développer mais penche toi sur la notion de référence : http://sametmax.com/valeurs-et-references-en-python/

[Sekigo Le Magnifique]

La fonction du module scikit que tu utilises attend quoi exactement comme argument ?
Si tu peux lui fournir un itérateur, ça peut résoudre ton problème de mémoire.

En gros, si j'ai bien compris, tu as d'un coté des objets qui ne te prennent pas de place en mémoire. De l'autre, la fonction attend un tableau. Et quand tu sérialises tes objets en tableau, paf, ça fait des chocapics.
L'idée, si c'est possible, c'est d'avoir plutôt d'avoir un objet implémentant la méthode __iter__ (qui utiliserait donc yield au lieu de return) qui renverrait au fur et à mesure les lignes à partir de tes objets, et que tu enverrais à la fonction scikit. Ainsi, tu n'as qu'une ligne en mémoire à la fois, et la fonction de scikit est contente parce qu'elle a ses lignes.
Bien entendu, cela suppose que la fonction scikit consomme les données au fur et à mesure. Si elle a besoin de faire des aller et retour dans le tableau, il faut gruger autrement (peut-être avec les références, ou autre chose, ça dépend du code).

Tu as un petit peu de code ? En particulier, la fonction scikit que tu utilises.

[Lazyjoe]

Je ne suis pas trop spécialiste de la question, mais si tes données peuvent se représenter sous la forme d'une matrice creuse c'est quand même assez classique comme format de données, ça m'étonnerait que ton module de stats ne soit pas capable de prendre une matrice creuse en entrée.

Edit : tiens, voilà un début de réponse : http://docs.scipy.org/doc/scipy/reference/sparse.html

[Janer]

@Lazijoe : Les matrices creuses sont un cas particulier du problème que je reccontre

@Sekigo : ok merci c'est une excellente piste. Pas de fonction en particulier je vais tester plusieurs modèles... Mon focus se fera sur les régression random forest.

@Teocali : oui, en utilisant les références c'est comme cela que je compte construire mon pseudo tableau!

[Anonyme32145]

Tu peux pas simplifier ta base ? Y'a des pistes pour faire des bases propre dans cet article qui fait référence dans la communauté stats R : tidy data.
Ça permet d'avoir une base très propre et ensuite tu peux faire de la vraie stat dessus

[Janer]

Tu peux pas simplifier ta base ? Y'a des pistes pour faire des bases propre dans cet article qui fait référence dans la communauté stats R : tidy data.
Ça permet d'avoir une base très propre et ensuite tu peux faire de la vraie stat dessus

C'est génial comme lecture! Je m'y plonge et je vois ce que je peux en tirer.

[Anonyme32145]

Pour info le mec qui a écrit ça est le mec qui a complètement développé tous les modules les plus utilisés actuellement sous R. La plupart des utilisateurs de R pourraient pas bosser sans ses librairies.

[Patate]

J'ai une petite question pour les canards c++ !
Dans mon petit jeu, je souhaiterais intégrer la sauvegarde / chargement de la partie. De façon simple, une seule partie en cours, donc au démarrage c'est "continuer" (si un fichier de save existe, sinon "nouvelle partie").

Vu l'avancement de mon projet, j'ai pas mal de classes avec des conteneurs, pas mal de pointeurs, de données, etc. J'ai regardé boost::serialization pour balancer tout ça dans un fichier mais il faut que j'écrive pour chaque classe les données à sauvegarder, charger. Et vu le nombre d'objets, si je peux passer par un moyen plus simple, je prends !

Le truc c'est qu'à la base de mon programme, j'ai un objet "Engine" qui initialise et gère tout le jeu. Il contient tous les managers et toutes les données. Il n'est pas possible de sérialiser l'objet Engine et tout son contenu avec de façon automatique en quelque sorte ?

[Tramb]

N'essaie pas. Cherry-picke dans ton état ce qui est nécessaire. Même dans un langage plus managé, la sérialisation brutale de toutes les données du jeu à partir d'un objet racine est quasi-systématiquement une connerie.
Et j'en ai débuggué des codes trop élégants à base de pickle python ou autres.
En plus si tu choisis ce que tu sauvegardes, ajoute des numéros de version. Et tu pourras sans doute gérer la compat' ascendante de tes sauvegardes au fur et à mesure que ton code continuera à évoluer, ce qui est précieux.
Mais il te faut quand même un framework pour itérer sur tous tes objets, les sérialiser, et savoir les reconstruire.

[Tomaka17]

Il me semble qu'en général le principe c'est que tu convertis entre ton état de jeu et une série d'objets plus simples, et ces objets-là tu les sérialises/désérialises bêtement.

[Nattefrost]

Tu sérialise en binaire pour des raisons particulières?
Je demande ça parce que j'avais fait un jeu et le choix de sérialiser en XML avait été fait pour pouvoir éditer des sauvegardes et créer des états de jeu particuliers soit pour faire une démo à qqun mais surtout pour faire des tests unitaires dans des cas bien précis.

Tant que je suis là j'ai une question : quelqu'un a déjà entendu causer ou même utilisé Crystal ? C'est bien moins avancé qu'un Rust ou Kotlin mais je suis assez curieux.