g33k inside : Parlons programmation

[Chunky]

Yen a qui vont aller aux TechDays organisés par Microsoft le 11-12-13 février (Palais des congrès à Paris) ?

Normalement je vais y aller moi, j'ai sélectionné quelques conf pour le lundi (je viendrais que le lundi 11, c'est plus orienté prog ^^)

09:30-10:30
Session Plénière - Jour 1

11:00-12:00
Introduction à Linq

13:00-14:00
Les nouveautés de C# 3.0

14:30-15:30
Introduction à F#

16:00-17:00
La Virtualisation de machine : présent et futur

17:30-18:30
Sécurité de la CLR dans le Framework 3.5

Mais bon ya plein de sujets intéréssants.. souvent aux même heures (à 13h C#3.0 et silverlight ), et des passages à creux (les 2 dernières conf m'intéressent que moyennement)

Le site & Le site des confs

(j'ai oublié de dire que l'entrée est gratuite )

[Urd]

L'introduction à F# ça me plairait bien.

Mais j'ai cours tout le lundi.

J'irai peut-être à celui-ci mercredi :

# 11:00 - 12:00
Exploration et analyse de Données (DataMining) (DEC208)

Si MS Analysis Services est un serveur OLAP, c'est aussi un efficace serveur de Datamining. Cette session présente les principes du Datamining et son implémentation avec Microsoft Analysis Services 2008. Outre la création et l'administration des modèles de mining, la plateforme de développement ainsi que les interfaces utilisateurs intégrés dans Excel vous seront présentées. Que ce soit pour l'optimisation d'une campagne marketing, de la prévision de l'évolution du chiffre d'affaire, la segmentation de clients, la proposition de ventes croisées pour un site web marchant, si vous souhaitez réellement ajouter de l'intelligence à vos applications décisionnelles cette session est faite pour vous.

[Chunky]

Putain ouais, surtout que je dois faire un dossier sur le DataMining (d'ailleurs t'as des bons liens là dessus?) ^^ Mais bon je pourrais pas venir plus longtemps.

[L@ndo]

[Urd]

Putain ouais, surtout que je dois faire un dossier sur le DataMining (d'ailleurs t'as des bons liens là dessus?) ^^ Mais bon je pourrais pas venir plus longtemps.

Le data mining c'est vaste... voici mes cours de data mining.

[O.P HxH]

Quoi !! Un topic sur la programmation ?!!

[Chunky]

Putain ouais, surtout que je dois faire un dossier sur le DataMining (d'ailleurs t'as des bons liens là dessus?) ^^ Mais bon je pourrais pas venir plus longtemps.

Le data mining c'est vaste... voici mes cours de data mining.

Je sais bien ^^ J'ai sûrement pris un sujet trop vaste mais du coup jvais pas trop rentrer dans le technique et expliquer plutôt son (ses) but et ses moyens, en tout cas merci beaucoup pour tes cours jvais regarder ça

[Frostis Advance]

Oula... moi j'connais pas grand chose par rapport à vous. En même temps, j'en ai pas l'utilité ^^

Alors je ne fais que du web.... (x)html, css et php/mysql
Faudrait aussi que je me mets à faire du Java, histoire de voir si ça peut m'apporter quelques choses... Et de l'action script pour du flash (si vous avez des bons liens tuto sur Flash CS3, chui preneur)

J'ai un profil de tech/admin réseaux Microsoft, donc au taf, c'est Active Directory sous server 2003, accompagné de GPO et tout l'tralala...

D'ailleurs ce serait pas mal de se dire ou on taf, histoire de voir si vos boites embauches, oupa. Ya des étudiants dans l'coin, mais pas que ça.

Pour ma part, chui prestataire en CDI dans une société qui s'appel NES (on est fanboy ou on l'est pas ^^), et donc, en tant que prestataire, chui à Telecom Italia depuis un an et 3 mois. Pour ceux qui ne savent pas, c'est Alice D'ou le fait de parler un peu d'ou vous bossez... si vous voyez ce que j'veux dire. Bref, chui tech/admin systèmes Microsoft, et je m'occupe du réseau interne à l'entreprise. Voili voilou! Et les TechDays, j'aimerais bien y aller, mais mon chef veut pas >_<

[Fischerman]

bon moi demain je suis au erts 2008 en support technique pour une conf
au cas ou y aurai des dojo men (^^'')

http://www.erts2008.org/

[Urd]

Un truc qui sert à rien : définir en clips qu'une fonction est une injection, surjection, voire bijection.

Code : Tout sélectionner

(deftemplate ensemble
    (slot nom)
)

(deftemplate element
    (slot nom)
    (slot ensemble)
)

(deftemplate rel-binaire
    (slot nom)
    (slot depart)
    (slot arrivee)
)

(deffacts fonction
    (ensemble (nom A))
    (ensemble (nom B))
    (element (nom e1) (ensemble A))
    (element (nom e2) (ensemble A))
    (element (nom e3) (ensemble A))
    (element (nom e4) (ensemble A))
    (element (nom e5) (ensemble A))
    (element (nom f1) (ensemble B))
    (element (nom f2) (ensemble B))
    (element (nom f3) (ensemble B))
    (element (nom f4) (ensemble B))
    (rel-binaire (nom R1) (depart A) (arrivee B))
    (R1 e1 f1)
    (R1 e2 f2)
    (R1 e3 f3)
    (R1 e4 f4)
    (R1 e5 f4)
)


(defrule fonction
    (declare (salience 2))
    (rel-binaire (nom R1) (depart ?a) (arrivee ?b))
    (forall 
        (and (R1 ?e ?f)
        (element (nom ?e) (ensemble ?a))
        (element (nom ?f) (ensemble ?b))
        )
        (not 
            (and (R1 ?e ?f2)    
            (test (neq ?f ?f2))
            )
        )        
    )
=> 
    (assert (fonction))
)    


(defrule surjection
    (declare (salience 2))
    (fonction)
    (rel-binaire (nom R1) (depart ?a) (arrivee ?b))
    (forall 
        (element (nom ?f) (ensemble ?b))
        (R1 ?e ?f)
        (element (nom ?e) (ensemble ?a))
    )
=> 
    (assert (surjection))
    (assert (jection))
)

(defrule injection
    (declare (salience 2))
    (fonction)
    (rel-binaire (nom R1) (depart ?a) (arrivee ?b))
    (forall 
        (and (R1 ?e1 ?f)        
        (element (nom ?f) (ensemble ?b))                
        (element (nom ?e1) (ensemble ?a))
        )
        (not
            (and (R1 ?e2 ?f)
            (test (neq ?e1 ?e2))
            )
        )
        
    )
=> 
    (assert (injection))
    (assert (jection))
)

(defrule bijection
    (declare (salience 2))
    (injection)
    (surjection)
=>
    (assert (bijection))
)

        
(defrule imprime_fonction
    (not (jection))
    (fonction)
=>
    (printout t "C'est une fonction" crlf)
)

(defrule imprime_non_fonction
    (not (fonction))
=>
    (printout t "Ce n'est pas une fonction" crlf)
)

(defrule imprime_injection
    (not (bijection))
    (injection)
=>
    (printout t "C'est une injection" crlf)
)

(defrule imprime_surjection
    (not (bijection))
    (surjection)
=>
    (printout t "C'est une surjection" crlf)
)

(defrule imprime_bijection
    (bijection)
=>
    (printout t "C'est une bijection" crlf)
)

Voilà, ça servait à rien mais c'était rigolo. Si quelqu'un a des idées de trucs à coder....

Spoiler:

Et pour ceux qui voudraient chipoter sur l'indentation, c'est l'indentation typique en clips.

En ce moment, je travaille sur un projet de création de moteur de recherche en C et Perl, ainsi que sur un projet de planification PDDL et VDL en Java.

Si quelqu'un a de la doc sur les projets en question, ça m'intéresse.

Merci.

edit : pour ceux qui voudraient me proposer PageRank, je suis déjà documenté dessus (et l'ai déjà codé). Je m'intéresse plutôt aux méthodes tf-idf en travaillant sur des documents qui ne pointent pas vers d'autres documents.

Ce qui m'intéresse surtout c'est la gestion des requêtes et le prétraitement sur les données, j'ai déjà codé tf-idf l'an dernier.

[Rayy]

j'ai rien pour toi, par contre si quelqu'un aurait des ressources assez intéressantes et autres que wiki sur les honeynets et les honeypots (pas de jeu de mot sur ces termes ), ça m'intéresse, faut que j'en fasse un par rapport au protocole IRC.

[Kenshin83]

essaie avec Zack

[Urd]

Mesurer la qualité de son code.

[Urd]

Spoiler:

Code : Tout sélectionner

#!/usr/bin/python

import os, re, glob, string

## choix de la base
base = "CISI"
#base = "CACM"

# on verifie que la base est bien une de celles definies par l'enonce
if not base in ["CISI", "CACM"]:
	print "La base doit etre CISI ou CACM"
	raise BaseError, "La base specifiee n'est pas traitee, veuillez traiter la base CISI ou CACM"







# stop-list (dans le repertoire CACM)
# liste des mots trop frequents dans chaque document que l'on ne prendra pas en compte
fichierstoplist= open(os.path.join("CACM", "common_words"), "r")
lignes=fichierstoplist.readlines()
fichierstoplist.close()
# on repertorie la stop list dans un dictionnaire (table de hachage)
# pour que la recherche soit plus facile
stopdico = {}
compteur = 0
for mot in lignes:
	# on enleve les espaces et autres caracteres parasites comme \n
	mot2=mot.strip()
	if not stopdico.has_key(mot2):
		compteur+=1
		stopdico[mot2]=compteur

print "Taille de l'anti-dictionnaire =", compteur, "termes."









#############################################################
#############################################################
#############################################################









def compte_occurence_pour_chaque_mot_range(listedindex):
	"""Renvoie une liste comportant les index ranges des mots apparaissant au moins une fois dans la ligne 'ligne' ainsi que le nombre de fois qu'ils apparaissent."""
	dictionnairef, listef={}, []

	
	listedindex.sort()

	indiceprecedent=-1
	for mot in listedindex:
		if mot!=indiceprecedent:
			if indiceprecedent!=-1:
				listef.append((indiceprecedent,compteur))
			indiceprecedent=mot
			compteur=1
		else:
			compteur+=1
	if indiceprecedent!=-1:
		listef.append((indiceprecedent,compteur))
	return listef














# fonction de parsage de balises dans un fichier

def parsage_de_balise_dans_les_fichiers(nomdufichier, antidictionnaire, nomdufichiersortietf, nomdufichiersortieidf):
	"""fonction qui parse les balises : elimine les balises autres que .T, .A, .W, .B et .I"""

	# dictionnaire : des mots dans la base
	# dictionnaireidf : indique combien de fois un mot apparait dans un document
	# lignecorpus : liste des mots presents dans chaque document (mots d'un document presents dans les balises .T, .A, .V et .W)

	dictionnaire, dictionnaireidf, lignecorpus= {}, {}, []

	# ouverture et fermeture du fichier
	# on recupere seulement ses lignes sur lesquelles on travaillera

	fichier=open(nomdufichier, 'r')
	lignes=fichier.readlines()
	fichier.close()

	# ouverture du fichier qui comportera les mots presents dans un documents et leur occurence dans le document

	fichiersortie=open(nomdufichiersortietf,"w")

	# indicateur de la balise dans laquelle on se trouve
	# lignequifaitpartieducorpusdudocument == True equivaut a on est dans une balise .T, .A, .V ou .W

	lignequifaitpartieducorpusdudocument=False

	# compteur : index d'un mot dans le dictionnaire
	# compteur2 == True equivaut a 

	compteur=0
	compteur2=False

	# identifiant du document

	identifiant=""

	nombrededocs=0

	for ligne in lignes:
		# reperage d'une balise
		if ligne[:1] == ".":
			# on regarde si on sur une balise .T, .A, .V ou .W
			if ligne[:2] in [".T" , ".A" , ".W" , ".B"]:
				lignequifaitpartieducorpusdudocument=True
			else: 
				lignequifaitpartieducorpusdudocument=False
				# on se retrouve sur une balise .I
				if ligne[:2] == ".I":
					dicoligne={}
					nombrededocs += 1
					if compteur2:
						# On recupere l'identifiant du document et on imprime son contenu dans un fichier
						liste2=compte_occurence_pour_chaque_mot_range(lignecorpus)
						fichiersortie.write(identifiant + " " + str(len(lignecorpus)) + " ")
						for a1, a2 in liste2:
							fichiersortie.write(" " + str(a1) + ":" + str(a2))
						fichiersortie.write("\n")
						# on vide le corpus du document pour mettre celui du suivant
						lignecorpus=[]
					else:
						compteur2=True					
					# on recupere l'identifiant du document
					identifiant=ligne.split(" ")[1].strip()

		# on est dans une balise  .T, .A, .V ou .W
		elif lignequifaitpartieducorpusdudocument:
			# ligne.lower() : on transforme les majuscules en minuscules
			# re.sub("[^a-z0-9]"," ",ligne.lower()) : on ne conserve que les caracteres alphanumeriques
			# on decoupe les espaces avec un split qui transforme le tout en liste
			ligne = re.sub("[^a-z0-9]"," ",ligne.lower()).split()
			for mot in ligne:
				# si le mot n'est pas present dans la stop liste, on travaille dessus
				if not mot in antidictionnaire:
					# si le mot n'a pas deja ete visite, on l'ajoute au dictionnaire
					if not dictionnaire.has_key(mot):
						compteur += 1
						dictionnaire[mot]=compteur
						dictionnaireidf[mot]=1
					# si le mot n'a pas deja ete visite dans le document, on l'ajoute a dictionnaireidf
					elif not dicoligne.has_key(mot):
						dictionnaireidf[mot] += 1
					dicoligne[mot]=1
					lignecorpus.append(dictionnaire[mot])


	# impression pour le dernier document a la sortie de la bouche
	fichiersortie.write(identifiant + " " + str(len(lignecorpus)) + " ")
	for a1, a2 in liste2:
		fichiersortie.write(" " + str(a1) + ":" + str(a2))		

	fichiersortie.close()

	# on imprime les valeurs des idf

	fichiersortie=open(nomdufichiersortieidf,"w")
	fichiersortie.write(str(nombrededocs) + " = nombre de documents\n")
	for d1, d2 in dictionnaireidf.iteritems():
		# chaque ligne du document : (mot, index du mot dans le dictionnaire, nombre de documents dans lequel il apparait)
		fichiersortie.write(d1 + "," + str(dictionnaire[d1]) + "," + str(d2) + "\n")
	fichiersortie.close()


	print "Taille du dictionnaire =", compteur




##############################################################################
##############################################################################






# Recherche des fichiers ".ALL" ou ".all"

fichierall = glob.glob(base + "/*.ALL")
if not fichierall:
	fichierall = glob.glob(base + "/*.all")


parsage_de_balise_dans_les_fichiers(fichierall[0], stopdico, "documenttf", "documentidf")

[Le poussin]

J'ai regardé rapidement, mais y'aurait des simplifications/clarifications possibles à droite à gauche.

[Urd]

Comme ? Ca m'intéresserait bien de savoir.

edit : je viens déjà de changer ça

Code : Tout sélectionner

			# on regarde si on sur une balise .T, .A, .V ou .W
			if ligne[:2] in [".T" , ".A" , ".W" , ".B"]:

et du coup ça aussi :

Code : Tout sélectionner

if not base in ["CISI", "CACM"]:

Sinon je ne vois pas... je n'ai pas encore les réflexes python.

[Le poussin]

Y'avait ça effectivement que j'avais noter.
Mais y'a moyen de faire encore un petit peu mieux :

Code : Tout sélectionner

if ligne[:2] in (".T", ".A", ".W", ".B"):

Python fait la différence entre des types mutables (comprendre non constants) ou non. Les listes (construites avec des [ ]) sont mutables, les tuples (construits avec des ( ) ) ne le sont pas.
C'est mieux d'utiliser des types non mutables quand c'est possible.

Je passe sur les choix de nommage qui ne facilitent pas la lecture (lignequifaitpartieducorpusdudocument ça fait long quand même ) et sur la présentation en général.

Utiliser les chaînes de formatage quand ça rend plus lisible :

Code : Tout sélectionner

fichiersortie.write("%s %d " % (identifiant, len(lignecorpus)))

au lieu de

Code : Tout sélectionner

fichiersortie.write(identifiant + " " + str(len(lignecorpus)) + " ")

Pour le split sur une regexp, tu peux faire plus simple :

Code : Tout sélectionner

ligne = re.split("[^a-z0-9]+", ligne.lower())

Si les underscores ne sont pas un problème, tu peux aussi utiliser \W qui est un équivalent de [^a-zA-Z0-9_].

Un détail, pas forcément utile :

Code : Tout sélectionner

if ligne[0] == ".":

(On peut accéder directement aux caractères.)

Code : Tout sélectionner

listef.append((mot,listedindex.count(mot)))

Une couche de parenthèses superflue (influence du Lisp ? ).

Des trucs un peu plus brutaux mais qui ont l'avantage de simplifier le code . La fonction compte_occurence_pour_chaque_mot_range (dont le commentaire serait à corriger ) peut s'écrire en une ligne :

Code : Tout sélectionner

def compte_occurence_pour_chaque_mot_range(listedindex):
  return [ listindex.count(mot) for mot in set(listindex) ]

Sinon, j'ai pas compris le pourquoi des valeurs que tu mets dans le stopdico (rempli en début).

Un truc qui dépend plus du goût de chacun, et qui n'est pas spécifique au Python : en général je préfère écrire

Code : Tout sélectionner

for x in list:
  if cas_particulier:
    continue
  traitement normal

plutôt que

Code : Tout sélectionner

for x in list:
  if cas_normal:
    traitement normal

Ça évite d'augmenter le niveau d'imbrication quand on commence à avoir plusieurs cas particuliers successifs à traiter. Et ça transcrit mieux le fait qu'on "ignore/zappe" les cas spéciaux, traités en groupe au début. Mais c'est plus "marquant" quand y'a un traitement spécial à faire pour le cas particulier (avant le continue).


Voilà, c'est à peu près tout je pense. Mais je ne me suis pas penché sur le côté algo, la présentation générale du code ne le rend pas très lisible, du coup j'ai un peu la flemme.


EDIT : Pour les regexp, \W est un équivalent de [^a-zA-Z0-9_], petit oubli.

[Urd]

Code : Tout sélectionner

listef.append((mot,listedindex.count(mot)))

Une couche de parenthèses superflue (influence du Lisp ? ).

Ca ne passe pas (du moins chez moi) avec des parenthèses en moins. Je viens de retester.

Je regarderai le reste plus tard. (Et les "_" sont un problème au passage)

Pour l'écriture à rallonge je préfère l'écriture hongroise (:vice:) mais tous les exemples que j'ai vus étaient écrits comme ça. Si c'était pas un devoir à rendre, les noms auraient été nettement plus courts.

[Le poussin]

Au temps pour moi pour le append, j'avais mal lu le truc.

Les noms à rallonge je ne sais pas si c'est une habitude d'algorithmiciens (j'avais un prof qui faisait pareil), mais en tout cas ça n'aide pas à la lecture. D'ailleurs en général j'utilise des noms de variables en anglais, ça permet des noms plus explicites et plus concis.

[Urd]

Pour le split sur une regexp, tu peux faire plus simple :

Code : Tout sélectionner

ligne = re.split("[^a-z0-9]+", ligne.lower())

Je ne comprenais pas d'où venait le problème mais après une demie heure de vérifications et revérifications, ta fonction ne fait pas ce que je voulais.

Bon, j'ai réussi à me débarasser de la fonction de rangement autrement donc j'ai pas testé ton autre truc.