Sujet Précédent Sujet Suivant

Java

nadjet1807 Messages postés 5 Date d'inscription lundi 14 novembre 2011 Statut Membre Dernière intervention 10 mars 2012 - 10 mars 2012 à 10:54
shaft_amine Messages postés 58 Date d'inscription mercredi 30 juillet 2008 Statut Membre Dernière intervention 1 février 2018 - 18 mars 2012 à 09:01
bonjour.j'ai un algorithme apriori mais ne fonctione pas .

//---- apriori.java

//---- input file need:
//---- 1. config.txt
//---- four lines, each line a integer
//---- item number, transaction number , minsup
//---- 2. transa.txt

package apriori_algo ;

import java.io.*;
import java.lang.Integer.* ;
import java.lang.Object.* ;
import java.util.*;
import org.jdom.*;
import org.jdom.output.*;
import java.lang.String.*;
//-------------------------------------------------------------
// Class Name : apriori
// Purpose : main program class
//-------------------------------------------------------------
public class apriori_algo {

public static void main(String[] args) throws IOException {

aprioriProcess process1=new aprioriProcess();
System.exit(0);

}
}

//-------------------------------------------------------------
// Class Name : aprioriProcess
// Purpose : main processing class
//-------------------------------------------------------------
class aprioriProcess {

//Nous allons commencer notre arborescence en crant la racine XML
//qui sera ici "personnes".
static Element racine ;//= new Element("Apriori");

//On cre un nouveau Document JDOM bas sur la racine que l'on vient de crer
static org.jdom.Document document ;// = new Document(racine);

private final int HT=1; // state of tree node (hash table or
private final int IL=2; // itemset list)
int N; // total item #
int M; // total transaction #
int minsup ;

Vector largeitemset = new Vector() ;
Vector candidate = new Vector() ;
Vector Support = new Vector() ;

String fullitemset;
String configfile = "config.txt" ;
String transafile = "transa25.txt" ;


//-------------------------------------------------------------
// Class Name : candidateelement
// Purpose : object that will be stored in Vector candidate
// : include 2 item
// : a hash tree and a candidate list
//-------------------------------------------------------------
class candidateelement {
hashtreenode htroot;
Vector candlist;
}


//-------------------------------------------------------------
// Class Name : hashtreenode
// Purpose : node of hash tree
//-------------------------------------------------------------
class hashtreenode {
int nodeattr; // IL or HT
int depth;
Hashtable ht;
Vector itemsetlist;

public void hashtreenode() {
nodeattr=HT;
ht=new Hashtable();
itemsetlist=new Vector();
depth=0;
}

public void hashtreenode(int i) {
nodeattr=i;
ht=new Hashtable();
itemsetlist=new Vector();
depth=0;
}
}


//-------------------------------------------------------------
// Class Name : itemsetnode
// Purpose : node of itemset
//-------------------------------------------------------------
class itemsetnode {
String itemset;
int counter;

public itemsetnode(String s1,int i1) {
itemset=new String(s1);
counter=i1;
}

public itemsetnode() {
itemset=new String();
counter=0;
}

public String toString() {
String tmp=new String();
tmp=tmp.concat("<"");
tmp=tmp.concat(itemset);
tmp=tmp.concat("",");
tmp=tmp.concat(Integer.toString(counter));
tmp=tmp.concat(">");
return tmp;
}
}


//-------------------------------------------------------------
// Method Name: printhashtree
// Purpose : print the whole hash tree
// Parameter : htn is a hashtreenode (when other method call this method,it is the root)
// : transa : special transaction with all items occurr in it.
// : a : recursive depth
// Return :
//-------------------------------------------------------------
public void printhashtree(hashtreenode htn,String transa,int a) {
if (htn.nodeattr == IL ) {
System.out.println("Node is an itemset list");
System.out.println(" depth :<"+htn.depth+">");
System.out.println(" iteset:<"+htn.itemsetlist+">");
}
else { // HT
System.out.println("Node is a hashtable");
if (htn.ht==null)
return;
for (int b=a+1;b<=N;b++)
if (htn.ht.containsKey(Integer.toString(getitemat(b,transa)))) {
System.out.println(" key:<"+getitemat(b,transa));
printhashtree((hashtreenode)htn.ht.get(Integer.toString(getitemat(b,transa))),transa,b);
}
}
}


//-------------------------------------------------------------
// Method Name: getconfig
// Purpose : open file config.txt
// : get the total number of items of transaction file
// : and the total number of transactions
// : and minsup
//-------------------------------------------------------------
public void getconfig() throws IOException {

FileInputStream file_in;
DataInputStream data_in;
String oneline=new String();
int i=0;

InputStreamReader input = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(input);
String response = "";

System.out.println("Appuyer sur 'C' changer la configuration and le fichier de transaction par défault");
System.out.print("Ou sur n'import quelle touche pour continuer. ");
try {
response = reader.readLine();
} catch (Exception e) {
System.out.println(e);
}

int res=response.compareTo("C") * response.compareTo("c");

if(res == 0) {
System.out.print("\nEnter new transaction filename: ");
try {
transafile = reader.readLine();
} catch (Exception e) {
System.out.println(e);
}
System.out.print("Enter new configuration filename: ");
try {
configfile = reader.readLine();
} catch (Exception e) {
System.out.println(e);
}
System.out.println("Filenames changed");
}

try {
file_in = new FileInputStream(configfile);
data_in = new DataInputStream(file_in);

oneline=data_in.readLine();
N=Integer.valueOf(oneline).intValue();
oneline=data_in.readLine();
M=Integer.valueOf(oneline).intValue();
oneline=data_in.readLine();
minsup=Integer.valueOf(oneline).intValue();
System.out.print("\n configuration: "+N+" items, "+M+" transactions, ");
System.out.println("minsup = "+minsup+"%");
System.out.println();
} catch (IOException e) {
System.out.println(e);
}
}


//-------------------------------------------------------------
// Method Name: getitemat
// Purpose : get an item from an itemset
// : get the total number of items of transaction file
// Parameter : int i : i-th item ; itemset : string itemset
// Return : int : the item at i-th in the itemset
//-------------------------------------------------------------
public int getitemat(int i,String itemset) {

String str1=new String(itemset);
StringTokenizer st=new StringTokenizer(itemset);
int j;

if (i > st.countTokens())
System.out.println("eRRor! in getitemat, !!!!");

for (j=1;j<=i;j++)
str1=st.nextToken();

return(Integer.valueOf(str1).intValue());
}


//-------------------------------------------------------------
// Method Name: itesetsize
// Purpose : get item number of an itemset
// Parameter : itemset : string itemset
// Return : int : the number of item of the itemset
//-------------------------------------------------------------
public int itemsetsize(String itemset) {
StringTokenizer st=new StringTokenizer(itemset);
return st.countTokens();
}


//-------------------------------------------------------------
// Method Name: gensubset
// Purpose : generate all subset given an itemset
// Parameter : itemset
// Return : a string contains all subset deliminated by ","
// : e.g. "1 2,1 3,2 3" is subset of "1 2 3"
//-------------------------------------------------------------
public String gensubset(String itemset) {

int len=itemsetsize(itemset);
int i,j;
String str1;
String str2=new String();
String str3=new String();

if (len==1)
return null;
for (i=1;i<=len;i++) {
StringTokenizer st=new StringTokenizer(itemset);
str1=new String();
for (j=1;j=minsup
// Parameter : int n : n-itemset
// Return :
//-------------------------------------------------------------
public void createlargeitemset(int n) {

Vector candlist=new Vector();
Vector lis=new Vector(); //large item set
hashtreenode htn=new hashtreenode();
int i;

// System.out.println("Generating "+n+"-large item set ....");
candlist=((candidateelement)candidate.elementAt(n-1)).candlist;
htn=((candidateelement)candidate.elementAt(n-1)).htroot;

getlargehash(0,htn,fullitemset,lis);

largeitemset.addElement(lis);

} // end public void createlargeitemset(int n)


//-------------------------------------------------------------
// Method Name: getlargehash
// Purpose : recursively traverse candidate hash tree
// : to find all large itemset
// Parameter : htnf is a hashtreenode (when other method call this method,it is the root)
// : cand : candidate itemset string
// : int i : recursive depth
// : Vector lis : Vector that stores large itemsets
// Return :
//-------------------------------------------------------------
public void getlargehash(int i,hashtreenode htnf,String transa,Vector lis) {

Vector tempvec=new Vector();
int j;

if (htnf.nodeattr==IL) {
tempvec=htnf.itemsetlist;
for (j=1;j<=tempvec.size();j++)
if (((itemsetnode)tempvec.elementAt(j-1)).counter >= ((minsup * M) / 100))
{
lis.addElement( ((itemsetnode)tempvec.elementAt(j-1)).itemset ) ;
Support.addElement(((itemsetnode)tempvec.elementAt(j-1)).counter ) ;
}

}
else {
if (htnf.ht==null)
return;
for (int b=i+1;b<=N;b++)
{
if (htnf.ht.containsKey(Integer.toString(getitemat(b,transa))))
getlargehash(b,(hashtreenode)htnf.ht.get(Integer.toString(getitemat(b,transa))),transa,lis);
}

}
}


//-------------------------------------------------------------
// Method Name: transatraverse
// Purpose : read each transaction, traverse hashtree,
// incrment approporiate itemset counter.
// Parameter : int n : n-itemset
// Return :
//-------------------------------------------------------------
public void transatraverse(int n) {

FileInputStream file_in;
DataInputStream data_in;
String oneline=new String();
int i=0,j=0,len=0;
String transa;
hashtreenode htn=new hashtreenode();
StringTokenizer st;
String str0;
int numRead=0;

//System.out.println("Traverse "+n+"-candidate hashtree ... ");
htn=((candidateelement)candidate.elementAt(n-1)).htroot;
try {
file_in = new FileInputStream(transafile);
data_in = new DataInputStream(file_in);

while ( true ) {
transa=new String();
oneline=data_in.readLine();
numRead++;
if ((oneline==null)||(numRead > M))
break;
st=new StringTokenizer(oneline.trim());
j=0;
while ((st.hasMoreTokens()) && j < N) {
j++;
str0=st.nextToken();
i=Integer.valueOf(str0).intValue();
if (i!=0) {
transa=transa.concat(" ");
transa=transa.concat(Integer.toString(j));
len++;
}
}
transa=transa.trim();
//transa=oneline.trim();
//System.out.println(transa);
transatrahash(0,htn,transa);
}
} catch (IOException e) {
System.out.println(e);
}
}


//-------------------------------------------------------------
// Method Name: transatrahash
// Purpose : called by transatraverse
// : recursively traverse hash tree
// Parameter : htnf is a hashtreenode (when other method call this method,it is the root)
// : cand : candidate itemset string
// : int i : recursive depth,from i-th item, recursive
// Return :
//-------------------------------------------------------------
public void transatrahash(int i,hashtreenode htnf,String transa) {

String stris=new String();
Vector itemsetlist=new Vector();
int j,lastpos,len,d;
itemsetnode tmpnode=new itemsetnode();

if (htnf.nodeattr==IL) {
itemsetlist=(Vector)htnf.itemsetlist;
len=itemsetlist.size();
for (j=0;j<len;j++) {
tmpnode=(itemsetnode)itemsetlist.elementAt(j);
d=getitemat(htnf.depth,tmpnode.itemset);
String v =Integer.toString(d) ;
lastpos=transa.indexOf(" "+v+" ");
if (lastpos!=-1)
((itemsetnode)(itemsetlist.elementAt(j))).counter++;
}
//return;
}
else //HT
for (int b=i+1;b<=itemsetsize(transa);b++)
if (htnf.ht.containsKey(Integer.toString(getitemat(b,transa))))
transatrahash(i,(hashtreenode)htnf.ht.get(Integer.toString(getitemat(b,transa))),transa);

} // public transatrahash(int ii,hashtreenode htnf,String transa)


//-------------------------------------------------------------
// Method Name: aprioriProcess()
// Purpose : main processing method
// Parameters :
// Return :
//-------------------------------------------------------------
public aprioriProcess() throws IOException {

candidateelement cande;
int k=0;
Vector large=new Vector();
Date d=new Date();
long s1,s2;

System.out.println();
System.out.println("Algorithm apriori starting now.....");
System.out.println();

getconfig();

fullitemset=new String();

fullitemset=fullitemset.concat("1");
for (int i=2;i<=N;i++) {
fullitemset=fullitemset.concat(" ");
fullitemset=fullitemset.concat(Integer.toString(i));
}

d=new Date();
s1=d.getTime();


while (true) {
k++;
cande=new candidateelement();
cande.candlist=createcandidate(k);



//System.out.println("C"+k+"("+k+"-candidate-itemset): "+cande.candlist);

if (cande.candlist.isEmpty())
break;

cande.htroot=null;
candidate.addElement(cande);

((candidateelement)candidate.elementAt(k-1)).htroot=createcandidatehashtree(k);

System.out.println("\nNow reading transactions, increment counters of itemset");
transatraverse(k);

createlargeitemset(k);
System.out.println("\nFrequent "+k+"-itemsets:");
System.out.println((Vector)(largeitemset.elementAt(k-1)));

String itemfrequent =String.valueOf(largeitemset.elementAt(k-1));

itemfrequent=itemfrequent.replace("[",",");
itemfrequent=itemfrequent.replace("]",",");
StringTokenizer sttt=new StringTokenizer(itemfrequent,",");

racine = new Element("Apriori");
document = new Document(racine);

Element Frequent = new Element("Frequent");
racine.addContent(Frequent);
String h= String.valueOf(k);
Attribute Niveau = new Attribute("Niveau",h);
Frequent.setAttribute(Niveau);

int o=1;
while (sttt.hasMoreTokens()) {

String hh = String.valueOf(o);
Element itemfreqent = new Element("itemfreqent");
Frequent.addContent(itemfreqent);

Attribute Num = new Attribute("Num",hh);
Attribute support = new Attribute("Support",String.valueOf(Support.elementAt(o-1)));

itemfreqent.setAttribute(Num);
itemfreqent.setAttribute(support);
String fer =sttt.nextToken().toString();

itemfreqent.setText(fer);

o++;
}
enregistre("Frequents du Niveau "+k+".xml");
//affiche();
Support = new Vector() ;
}

hashtreenode htn=new hashtreenode();
htn=((candidateelement)candidate.elementAt(k-2)).htroot;

d=new Date();
s2=d.getTime();
System.out.println();

System.out.println("Execution time is: "+((s2-s1)/1000) + " seconds.");

System.out.println("End.");

//affiche();
//enregistre("Itemfrequent.xml");

}
//==============================================================================
//
// Afficher le contenue du fichier XML
//
//==============================================================================
static void affiche()
{
try
{
//On utilise ici un affichage classique avec getPrettyFormat()
XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
sortie.output(document, System.out);
}
catch (java.io.IOException e){}
}

//==============================================================================
//
// Enregistrer dans le fichier XML
//
//==============================================================================

static void enregistre(String fichier)
{
try
{
//On utilise ici un affichage classique avec getPrettyFormat()
XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
//Remarquez qu'il suffit simplement de crer une instance de FileOutputStream
//avec en argument le nom du fichier pour effectuer la srialisation.
sortie.output(document, new FileOutputStream(fichier));
}
catch (java.io.IOException e){}
}

//==============================================================================
//
//
// Apriori Parametrer
//
//
//==============================================================================



}

5 réponses

Réponse 1 / 5
cs_Julien39 Messages postés 6414 Date d'inscription mardi 8 mars 2005 Statut Modérateur Dernière intervention 29 juillet 2020 371
10 mars 2012 à 12:16
Bonjour,

Est ce que tu penses sincèrement que quelqu'un va lire tout ton programme pour détecter l'erreur ?

Si tu ne fais pas l'effort de décrire ce qui te poses problème, tu n'auras pas de réponse. Essaye d'extraire les lignes qui te posent problème et de nous dire ce qui ne va pas : exception, fonctionnement inattendu, problème de rafraichissent d'une fenêtre ?
0
Réponse 2 / 5
nadjet1807 Messages postés 5 Date d'inscription lundi 14 novembre 2011 Statut Membre Dernière intervention 10 mars 2012
10 mars 2012 à 13:11
les ligne qui pose le probleme est :668.669.663.678.679.720.739.34.662.665.719.736.37.3.9.666.10.492.
0
Réponse 3 / 5
cs_Julien39 Messages postés 6414 Date d'inscription mardi 8 mars 2005 Statut Modérateur Dernière intervention 29 juillet 2020 371
10 mars 2012 à 15:29
Allez, encore un effort, peux tu nous recopier la trace de ton exception et également les lignes qui sont à l'origine de la première exception qui est levée (celle qui apparait en premier).

Sinon, je ne pourrai pas t'aider.
0
Réponse 4 / 5
cs_Julien39 Messages postés 6414 Date d'inscription mardi 8 mars 2005 Statut Modérateur Dernière intervention 29 juillet 2020 371
14 mars 2012 à 12:14
Franchement, vu comme tu as posé la question, il ne faut pas t'étonner de ne pas avoir reçu d'aide...
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 5
shaft_amine Messages postés 58 Date d'inscription mercredi 30 juillet 2008 Statut Membre Dernière intervention 1 février 2018
18 mars 2012 à 09:01
C'est mon algorithme nadjet1807 ca fonctionne bien il faut d'abord bien lire ce que j'ai écri concernant l'API jdom pour créer les fichier XML contenet les itemsets fréquent
0

Discussions similaires

trier un iterator
lafolle24320 -
Twinuts -

9 réponses
la division en java
cs_aliomar -
KIRAIII -

3 réponses
Le Mapping en Java: Map(Key,Value)
cs_developppez -
icecube005 -

2 réponses
la difference entre a++ et ++a
waluigii -
Twinuts -

2 réponses
Problème de division réelle (et oui...)
playmo420 -
nomad56 -

4 réponses
Rejoignez-nous