Online Web Mining Transactions Association Rules using Frame Metadata Model1 Joseph Fong J.G. Hughes, Jianhan Zhu Department of Computer Science Northern Ireland Knowledge Engineering City University of Hong Kong, Hong Laboratory Kong University of Ulster, Belfast, Northern Ireland Email:
[email protected] Email:{jg.hughes, jh.zhu}@ulst.ac.uk Abstract In this paper, we introduce a frame metadata model to facilitate the continuous association rules of web transactions. A new set of association rules can be derived with the update of the web log file by the web transactions in the frame metadata model. The frame metadata model consists of two types of classes: static classes and active classes. The static classes describe the web transactions of the association rule table. The active classes are event driven, obtaining web transactions when invoked by a certain event. Whenever an update occurs in the existing web transactions in the web log file, a corresponding update will be invoked by an event attribute in the method class which will compute the association rules continuously. The result is an active web mining capable of deriving association rules of a web transactions continuously or incrementally using frame metadata model.
1 Introduction The process of keeping the support and confidence upto-date in response to the changes in the web transaction data is to generate new set of association rules on-line[1]. Deriving association rules can be achieved by full recomputation of the support and confidence level of association rule continuously or incrementally by computing new record counts in the source database
users’ use of Cookies, and map all the information into a main table for further processing of web transactions extraction. The main table can be stored in common commercial database. We then select interested records into transaction table, such as transactions made by users. We have a range of URL addresses related to transactions as shown in Figure 1. The frame metadata model consists of four classes: the header class identifies each fact table, the attribute class defines its attributes’ properties, the method class stores its data operations and condition, and the constraint class describes each event occurrence. They can be used to implement an event driven active web mining. When an event occurs, it triggers a process in the constraint class, which calls for the operations in the method class for action. Web transactions can be actively updated to generate the association rules for decision support systems. The result is an active web mining. For example, an association rule below indicates that the transactions of A1, A2,…An will most likely associate with the web transactions of B. A1, A2, ……An => B The Support and Confidence level of this association is: Re cord _ Count ( A1 ∩ A2 ∩ ... ∩ An ∩ B ) Support = *100% Re cord _ Count of source data Confidence =
created since last computing date. In web mining, we analyze users’ activities on a website using web log file. To extract transaction activities for association rules, we can combine Web Server Log File with Record from
1
This paper is funded by Strategic Research Grant 7000895 of City University of Hong Kong
Re cord _ Count ( A1 ∩ A2 ∩ ... ∩ An ∩ B ) *100% Re cord _ Count ( A1 ∩ A2 ∩ ... ∩ An )
Each record is composed of: IP address
Time stamp
IP
Web Server Log
Method
Time
Http protocol
method
URL
URL
…
Status code
Bytes transferred
ID
URL
Time
Serial Number in Transaction
Record by using Cookie Main Table
Web Transaction Table
Figure 1 Web log file processing The approach is to compute Support and Confidence frame metadata model for checking the occurrence of level of web transactions by the method class of the the event as shown in Figure 2. frame metadata model, and by the constraint class of the
Web log file
Web log file processing
Frame Metadata Model Association Relational Rule schema table
initial load data R Web Transaction table
Generated SQL for data mining Object association rule Association rules Frame Association Model RDBMS rules report Agent
incremental data dR (to-be-updated data) Figure 2 Architecture of web mining association rules using frame metadata model
Object Frame model Agent is an executor which invokes the constraint class and the method class in the frame metadata model to generate the required SQL transactions for computing association rules statistical figures Support and Confidence level.
2 Related work In [10], the authors have proposed a spectrum of architectural alternative for coupling mining with database system. The work presented in [11] discusses data mining based on association rules for two numeric attributes and one Boolean attribute. The algorithms presented in [12] provide an efficient and scalable parallel computation for mining association rules. The problem of lack of complete and stepwise case study on the KDD process using the suggested stages by [13] is addressed. [17] discussed the process of mapping web log file into multi-dimensional cube for data mining, [18] discussed web log file format and related processing techniques. In [2,3,4], the authors presented structures of web mining process, from preparing web log data to the implementation of traditional data mining algorithms on them. The approaches adopted by data miners on web mining include association rules, sequential patterns, clustering, classification etc. Besides association rules, in [5], the authors discussed discovery of users’ navigation patterns from web log file using sequence. Web mining relied mainly on log file information to develop an association[6]. [7] presented a Association Rule Hypergraph Partitioning and Principal Component Partitioning to automatically discover document associations.
3 Frame metadata model A frame metadata model [16] consists of header, attributes, methods, and constraints as follows: Header Class { Class_name // an unique name in all system Parents // a list of superclass names Operation // program call for operations
Class_type // active or static class} Attribute Class { Attributes_name // an attribute in this class Class_name // reference to header class Method_name // a method in this class Attributes_type // attribute data type Association attribute // pointer to another class Default_value // predefined value Cardinality // single or multi-valued Description // description of the attributes} Method Class { Method_name //a method component in this class Class_name // reference to header class Parameters // Number of arguments for the method Method_type // return type of method Condition // the rule conditions Action // the rule actions} Constraint Class { Constraint_name //a constraint component of this class Class_name // reference the header class Method_name // constrict method name Parameters //Number of argument for the method Ownership // the class name of method owner Event // triggered event: create update or delete Sequence // method action time: before or after Timing // the method action timer}
4 Continuous Web mining association rules In web mining, users activities on website are recorded into log file online. We can identify each user identity through cookies, name of the directory set up dynamically for this user’s transaction record, IP address, or credit card number etc. The Web Transaction Table is continuously updated even though a set of association rules have been derived from the Web Transaction Table before. In order to maintain the current status of the association rules, we need to update the statistical analysis of association rules continuously whenever the Web Transaction Table being updated. This can be accomplished in Figure 3.
Web Log file No (1 )Extract Data according to web server
Transaction Table
Cookie Record Exisits?
Algorithm for discovering association rules continuously
Concise Transaction Table
yes Main Table with Cookie
Main Table
(4) Selected transaction record according user requirements (5) load da into target database
(3) Data with user ID RDB for stori concise transaction tab
(2) Group records by users RDBMS Data Method Class
Methods Constraint (Store Procedures) Class
Retrieve Method
Retrieve Constraints
Retrieve Invoke MethodConstraints Query Method
Data Modify
Methods Query Result Constraints for Before Action Result
More
Terminate
Error Process Result
Result
Methods Query Result Constraints for Result After Action Execute SQL Result Command
More
Error Terminate OFMA Process (RDBMS)
Figure 3 Data flow of frame object agent model API In c, Web Server Log File has many kinds of formats according to different web server or settings of taking records. The items in one record are divided with specific separator. In d, merge record of using cookies into Main Table. Cookie ID will differentiate each user from others. The disadvantage is that some user will disable cookie. In e, consult with web site designer about generic form of transaction being done in this web site. How many steps will consist each transaction. How to assign Transaction ID, according to directory name set up when transactions were instantiated or other unified number space agreed by web site designers. Then we use this metadata for select out those records related to transactions into Transaction Table. In f, after confirming the occurrence of each transaction (not an invalid one), we further divide the URL into details of the transaction, such as type of goods, quantities, brands etc. We also divide big transactions with many items into smaller ones to fit into the table for data mining stage. In g, change the concise transaction table according to specific data mining tasks, algorithms D …
URL …
Time …
Begin Open Web log file; Extract web log record into a main table according to users identification in Cookie; Extract web transaction table according to each URL; Extract concise web transaction table according to each transaction; Select target attributes for statistical analysis; Select associated parameter attributes for statistical analysis; Input minimum confidence and support level for association rules by the users; While a new web transaction occurs do begin Compute record count of concise web transaction table; For each parameter attribute do Begin compute web transactions count of parameter attribute; Compute web transactions count of target attribute with its associated parameter attribute; Compute support = ((target and associated parameter attribute web transactions count) / (total web transactions count )) * 100%; Compute confidence = ((target and associated parameter attribute web transactions count) / (parameter attribute web transaction count )) * 100%; If (computed support ≥ minimum requested support) and (computed confidence ≥ minimum requested confidence) Then associate rule: parameter attribute(s) => target attribute; End End End We can implement the algorithm by frame metadata model such that the record count will be computed by the attribute Action in its method class. The operation can be triggered by its constraint class whenever there is an update to the source relation. For example, given web transaction table and its target attribute A and parameter attributes B, C, D, E from transaction recorded in a web log file. We can extract transactions from web log file and record their occurrences as follows: Source Transaction Table: Serial Number in Transaction …
Source Concise Transaction Table ID
Last Name … … … … …
… … … … …
First Name … … … … …
Card Number … … … … …
Item
Size
Brand
Start Time
End Time
A B C D E
… … … … …
… … … … …
… … … … …
… … … … …
Source Association rule relation RS A a1 … an
B b1 … bn
C c1 … cn
D d1 … dn
We can then create an association rule table AR to hold its record count as follows: Rule 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Parameter count Count(B) Count(C) Count(D) Count(E) Count(B, C) Count(B, D) Count(B, E) Count(C, D) Count(C, E) Count(D, E) Count(B, C, D) Count(B, C, E) Count(B, D, E) Count(C, D, E) Count(B, C, D, E)
E e1 … en
Association Rule table AR:
Rule count Count(B, A) Count(C, A) Count(D, A) Count(E, A) Count(B, C, A) Count(B, D, A) Count(B, E, A) Count(C, D, A) Count(C, E, A) Count(D, E, A) Count(B, C, D, A) Count(B, C, E, A) Count(B, D, E, A) Count(C, D, E, A ) Count(B, C, D, E, A)
Potential association rule B => A C => A D => A E => A B, C => A B, D => A B, E => A C, D => A C, E => A D, E => A B, C, D => A B, C, E => A B, D, E => A C, D, E => A B, C, D, E => A
Class AR in Frame Metadata model for association table: Header Class Class Name AR
Parents 0
Operation Call Update_B&A Call Update_C&A Call Update_D&A Call Update_E&A Call Update_BC&A Call Update_BD&A Call Update_BE&A Call Update_CD&A Call Update_CE&A Call Update_DE&A Call Update_BCD&A Call Update_BCE&A Call Update_BDE&A Call Update_CDE&A Call Update_BCDE&A
Class Type Active
Attribute class Attribute_name Rule Parameter count Rule count Potential association rule
Class_ name AR AR AR AR
Method _name
Attribute _type Integer Integer Integer String
Associate_ attribute
Defaut_v alue
Cardin ality
Descript ion
Constraint class Constraint_ Name Update_B&A Update_C&A Update_D&A Update_E&A Update_BC&A Update_BD&A Update_BE&A Update_CD&A Update_CE&A Update_DE&A Update_BCD&A Update_BCE&A Update_BDE&A Update_CDE&A Update_BCDE&A
Method_name Update_B&A Update_C&A Update_D&A Update_E&A Update_BC&A Update_BD&A Update_BE&A Update_CD&A Update_CE&A Update_DE&A Update_BCD&A Update_BCE&A Update_BDE&A Update_CDE&A Update_BCDE&A
Class_N ame AR AR AR AR AR AR AR AR AR AR AR AR AR AR AR
Parame ter δR δR δR δR δR δR δR δR δR δR δR δR δR δR δR
Owner ship self self self self self Self self self self self self self self self self
Event Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert
Sequen ce After After After After After After After After After After After After After After After
Timing repeat repeat repeat repeat repeat repeat repeat repeat repeat repeat repeat repeat repeat repeat repeat
Method class Method_ name Update_ B&A
Class_ name AR
Parameter
Method _type Tuple
Condition
Action
Rs, @A, rule
δR, @B,
If (Select * from R s where δR.A=@A and δR.B=@B) ≠null
Update AR set count(B) =count(B)+1 Set count(B,A)=count(B,A)+1 where rule=1 Update AR set count(C) =count(C)+1 Set count(C,A)=count(C,A)+1 where rule=2 Update AR set count(D) =count(D)+1 Set count(D,A)=count(D,A)+1 where rule=3 Update AR set count(E) =count(E)+1 Set count(E,A)=count(E,A)+1 where rule=4 Update AR set count(B,C) =count(B,C)+1 Set count(B,C,A) = count(B,C,A)+1 where rule=5 Update AR set count(B,D) =count(B,D)+1 Set count(B,D,A) = count(B,D,A)+1where rule=6 Update AR set count(B,E) =count(B,E)+1 Set count(B,E,A) = count(B,E,A)+1where rule=7 Update AR set count(C,D) =count(C,D)+1 Set count(C,D,A) = count(C,D,A)+1where rule=8 Update AR set count(C,E) =count(C,E)+1 Set count(C,E,A) = count(C,E,A)+1where rule=9 Update AR
Update_ C&A
AR
Rs, @A, rule
δR, @C,
Tuple
If (Select * from R s where δR.A=@A and δR.C=@C) ≠null
Update_ D&A
AR
Rs, @A, rule
δR, @D,
Tuple
If (Select * from R s where δR.A=@A and δR.D=@D) ≠null
Update_ E&A
AR
δR, Rs, @A,@E, Rule
Tuple
If (Select * from R s where δR.A=@A and δR.E=@E) ≠null
Update_ BC&A
AR
Tuple
If (Select * from R s where δR.A=@A and δR.B=@B and δR.C=@C)≠null
Update_ BD&A
AR
Tuple
If (Select * from R s where δR.A=@A and δR.B=@B and δR.D=@D)≠null
Update_ BE&A
AR
Tuple
If (Select * from R s where δR.A=@A and δR.B=@B and δR.E=@E)≠null
Update_ CD&A
AR
Tuple
If (Select * from R s where δR.A=@A and δR.C=@C and δR.D=@D)≠null
Update_ CE&A
AR
Tuple
If (Select * from R s where δR.A=@A and δR.C=@C and δR.E=@E)≠null
Update_
AR
Rs, δR, @A,@B,@ C, Rule δR, Rs, @A,@B,@ D, Rule Rs, δR, @A,@B,@ E, Rule Rs, δR, @A,@C,@ D Rule δR, Rs, @A,@C,@ E Rule Rs, δR,
Tuple
If (Select * from R s where
DE&A Update_ BCD&A
AR
Update_ BCE&A
AR
Update_ BDE&A
AR
Update_ CDE&A
AR
Update_ BCDE& A
AR
@A,@D,@ E, Rule Rs, δR, @A,@B,@ C,@D Rule Rs, δR, @A,@B,@ C,@E Rule Rs, δR, @A,@B,@ D,@E Rule δR, Rs, @A,@C,@ D,@E Rule δR, Rs, @A,@B,@ C,@D,@E Rule
δR.A=@A and δR.D=@D and δR.E=@E)≠null Tuple
Tuple
Tuple
Tuple
Tuple
If (Select * from R s where δR.A=@A and δR.B=@B and δR.C=@C and δR.D=@D)≠null If (Select * from R s where δR.A=@A and δR.B=@B and δR.C=@C and δR.E=@E)≠null If (Select * from R s where δR.A=@A and δR.B=@B and δR.D=@D and δR.E=@E)≠null If (Select * from R s where δR.A=@A and δR.C=@C and δR.D=@D and δR.E=@E)≠null If (Select * from R s where δR.A=@A and δR.B=@B and δR.C=@C and δR.D=@D and δR.E=@E)≠null
As a result, the Support and Confidence level of each rule can be computed and summarized in the
following table:
Rule
Support
Confidence
1
Support 1 = (Count(B, A)/n)*100% Support 2 = (Count(C, A)/n)*100% Support 3 = (Count(D, A)/n)*100% Support 4 = (Count(E,A)/n)*100% Support 5 = (Count(B,C,A)/n)* 100% Support 6 = (Count(B,D,A)/n) * 100% Support 7 = (Count(B,E,A)/n)* 100% Support 8 = (Count(C,D,A)/n)* 100% Support 9 = (Count(C,E,A)/n)* 100% Support 10 = (Count(D,E,A)/n)* 100% Support 11 = (Count(B,C,D,A)/n)* 100% Support 12 = (Count(B,C,E,A)/n)* 100% Support 13 = (Count(B,C,D,A)/n)* 100% Support 14 = (Count(C,D,E,A)/n)* 100%
Confidence 1 = (Count(B, A) Count(B)) * 100% Confidence 2 = (Count(C, A) Count(C)) * 100% Confidence 3 = (Count(D, A) Count(D)) * 100% Confidence 4 = (Count(E, A) Count(E)) * 100% Confidence 5 = (Count(B,C,A) Count(B,C)) * 100% Confidence 6 = (Count(B,D,A) Count(B,D)) * 100% Confidence 7 = (Count(B,E,A) Count(B,E)) * 100% Confidence 8 = (Count(C,D, A) Count(C,D)) * 100% Confidence 9 = (Count(C,E, A) Count(C,E)) * 100% Confidence 10 = (Count(D,E, A) Count(D,E)) * 100% Confidence 11 = (Count(B,C,D,A) Count(B,C,D)) * 100% Confidence 12 = (Count(B,C,E, A) Count(B,C,E)) * 100% Confidence 13 = (Count(B,C,D, A) Count(B,C,D)) * 100% Confidence 14 = (Count(C,D,E, A) Count(C,D,E)) * 100%
2 3 4 5 6 7 8 9 10 11 12 13 14
set count(D,E) =count(D,E)+1 Set count(D,E,A) = count(D,E,A)+1where rule=10 Update AR set count(B,C,D) =count(B,C,D)+1 Set count(B,C,D,A) = count(B,C,D,A)+1where rule=11 Update AR set count(B,C,E) =count(B,C,E)+1 Set count(B,C,E,A) = count(B,C,E,A)+1where rule=12 Update AR set count(B,D,E) =count(B,D,E)+1 Set count(B,D,E,A) = count(B,D,E,A)+1where rule=13 Update AR set count(C,D,E) =count(C,D,E)+1 Set count(C,D,E,A) = count(C,D,E,A)+1where rule=14 Update AR set count(B,C,D,E) =count(B,C,D,E)+1 Set count(B,C,D,E,A) = count(B,C,D,E,A)+1where rule=15
Condition / / / / / / / / / / / / / /
If Support 1 ≥ S m And Confidence 1 ≥ C m If Support 2 ≥ S m And Confidence 2 ≥ C m If Support 3 ≥ S m And Confidence 3 ≥ C m If Support 4 ≥ S m And Confidence 4 ≥ C m If Support 5 ≥ S m And Confidence 5 ≥ C m If Support 6 ≥ S m And Confidence 6 ≥ C m If Support 7 ≥ S m And Confidence 7 ≥ C m If Support 8 ≥ S m And Confidence 8 ≥ C m If Support 9 ≥ S m And Confidence 9 ≥ C m If Support 10 ≥ S m And Confidence 10 ≥ C m If Support 11 ≥ S m And Confidence 11 ≥ C m If Support 12 ≥ S m And Confidence 12 ≥ C m If Support 13 ≥ S m And Confidence 13 ≥ C m If Support 14 ≥ S m And Confidence 14 ≥ C m
Associatio n rule B => A C => A D => A E => A B,C => A B,D => A B,E=> A C,D => A C,E => A D,E => A B,C,D A B,C,E A B,D,E A C,D,E A
=> => => =>
15
Support 15 = (Count(B,C,D,E,A)/n) * 100%
Confidence 15 = (Count(B,C,D,E, A) / Count(B,C,D,E)) * 100%
We have to derive association rules incrementally by storing the web transactions count of the previous computing date into an Association Rule Table and adding the new record counts Date Date1 Date1 Date1 Date2 Date2 Date2
A a1 … an a1’ … am
B b1 … bn b1’ … bm
Rule 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Parameter count Count(B) Count(C) Count(D) Count(E) Count(B, C) Count(B, D) Count(B, E) Count(C, D) Count(C, E) Count(D, E) Count(B, C, D) Count(B, C, E) Count(B, D, E) Count(C, D, E) Count(B, C, D, E)
C c1 … cn c1’ … cm
D d1 … dn d1’ … dm
5 Prototype A prototype has been implemented for frame object agent model, which is an Application Program Interface developed to invoke the data operation in the frame model for data semantics management. The API process handles the method defined by Constraint class during data modification. The process defined and executed by RDBMS is to provide triggering event fired on the class. When RDBMS process is invoked, it will check from the Constraint class for any associated method. If method is defined in the Constraint class, the method definition will be queries. The process will invoke the stored procedure defined by the queried method definition. If executed result returned by stored procedure violated the rule
E e1 … en e1’ … em
Association Rule table AR with timestamp at Date2.
Rule count Count(B, A) Count(C, A) Count(D, A) Count(E, A) Count(B, C, A ) Count(B, D, A) Count(B, E, A) Count(C, D, A) Count(C, E, A) Count(D, E, A) Count(B, C, D, A) Count(B, C, E, A) Count(B, D, E, A) Count(C, D, E, A) Count(B, C, D, E, A)
We can use the same calculation as described in computing association rule continuously, except the total transaction record count of source relation is n + m.
B,C,D,E => A
during the new computing transaction as follow: Web transaction table RS with timestamp at Date1 and Date2.
We can create an association rule table AR to hold its transaction occurrence count as follows: Date Date2 Date2 Date2 Date2 Date2 Date2 Date2 Date2 Date2 Date2 Date2 Date2 Date2 Date2 Date2
If Support 15 ≥ S m And Confidence 15 ≥ C m
Potential association rule B => A C => A D => A E => A B, C => A B, D => A B, E => A C, D => A C, E => A D, E => A B, C, D => A B, C, E => A B, D, E => A C, D, E => A B, C, D, E => A
defined in Constraint class, error message will be returned to the user (refer to Figure 3). The situation is that an online shopping centre has a collection of commodities from television to fruits. In Figure 4, we process web log file into Main Table. Merge Cookie information.
Figure 4: Process Web Log File In figure 5, we transform Main Table into Transaction Table, corresponding to procedure e in figure 3. In figure 6, we process Transaction Table into Concise Transaction Table, corresponding to procedure f and g in figure 3. .
[4]
[5]
Figure 5: Process Main Table into Transaction Table
[6] [7]
Figure 6 Process Transaction Table into Concise [8]
[9]
[10]
Figure 7 All significant association rules for the target attribute television (confidence=20%, support=0.2%) In Figure 7, we select television as our target and get the rules based on confidence level 20% and support 0.2%.
[11]
6 Conclusion This paper presents a solution to the problem by using a frame metadata model to invoke record count program in a metadata whenever relevant new record is created in the target database. As a result, web mining association rules can be accomplished online or incrementally without the need to re-compute the historical web transaction counts. The metadata thus contributes saving of computing time and also the automation of data mining association rules non-stop. The future research of this paper is web mining web pages association rules via Internet.
References [1]
[2]
[3]
Chen, Q., Hsu, M. and Dayal, U., A Data Warehouse/OLAP Framework for Scalable Telecommunication Tandem Traffic Analysis, a report of Software Technology Laboratory, HP Labs, 1501 Page Mill Road, MS 1U4, Palo Alto, CA 94303, USA Robert Cooley, Bamshad Mobasher, and Jaideep Srivastava, Data Preparation for Mining World Wide Web Browsing Patterns, Journal of Knowledge and Information Systems, Vol. 1, No. 1, 1999 Robert Cooley, Bamshad Mobasher, and Jaideep Srivastava, Grouping Web Page References into Transactions for Mining World Wide Web Browsing Patterns, Proceedings of the 1997 IEEE Knowledge
[12] [13] [14]
[15]
[16] [17]
[18]
and Data Engineering Exchange Workshop (KDEX97), November 1997. A.G. Büchner, M.D. Mulvenna, S.S. Anand, J.G. Hughes, An Internet-enabled Knowledge Discovery Process, the 9th International Database Conference, Hong Kong, pp. 13-27, July 1999. Cookie A.G. Büchner, M. Baumgarten, S.S. Anand, M.D. Mulvenna, J.G. Hughes, Navigation Pattern Discovery from Internet Data, ACM Workshop on Web Usage Analysis and User Profiling (WebKDD), San Diego, CA, pp. 25-30, 1999. Mena, Jesus, Data Mining Your Website, Digital Press, 1999, pp. 313-314. Moore J., Han E., Boley D., Gini M., Gross R., Hstings K., Karypis G., Kumar V and Mobasher B., Web Page Categorization and Feature Selection Using Association rule and Principal Component Clustering, University of Minnesota. M. Mohania, S. Madria and Y. Kambayashi, SelfMaintainable Aggregate Views, Proceedings of the 9th International Database Conference, City University of Hong Kong Press, ISBN 962-937-046-8, p.306-317. T.Griffin and L. Libkin, Incremental maintenance of views with duplicates, Proceedings of the International Conference on Management of Data, 1995. Sunita Sarawagi, Shiby Thomas and Rakesh Agrawal, Integrating Association Rule Mining With Relational Database Systems: Alternatives and Implications, ACM 1998, pp343-354. Takeshi Fukuda, Yasuhiko Morimoto, Shinichi Morishita and Takeshi Tokuyama, Data Mining Using Two-Dimensional Optimized Association Rules: Scheme, Algorithms, and Visualization, ACM 199, pp13-23. Eui-Hong (Sam) Han, George Karypis and Vipin Kumar, Scalable Parallel Data Mining for Association Rules, ACM 1997, pp277-288. Pieter Adriaans and Dolf Zantinge, Data Mining, Addision Wesley, ISDN 0-201-40380-3. Fong, J., Huang, S., Architecture of a Universal Database: A Frame Model Approach, International Journal of Cooperative Information Systems, Volume 8, Number 1, March 1999, pp.47-82. Fong, J. and Pang, F., Schema Evolution for New Database Applications: A Frame Metadata model Approach, Proceedings of Systems, Cybernetics and Informatics, Volume 5, 1999, pp. 104-111. Fong, J., Huang, S., Information Systems Reengineering, Springer Verlag, ISBN 981-3083-158, 1997, pp179-212 O. R. Zaiane, M. Xin, J. Han, Discovering Web Access Patterns and Trends by Applying OLAP and Data Mining Technology on Web Logs, Proceedings Advances in Digital Libraries Conference (ADL'98), Santa Barbara, CA, April 1998, pp. 19-29. A.G. Büchner, M.D. Mulvenna, Discovering Internet Marketing Intelligence through Online Analytical Web Usage Mining, ACM SIGMOD Record, ISSN 0163-5808, Vol. 27, No. 4, pp. 54-61, 1998.
