PAMI.weightedFrequentRegularPattern.basic package

Submodules

PAMI.weightedFrequentRegularPattern.basic.WFRIMiner module

class PAMI.weightedFrequentRegularPattern.basic.WFRIMiner.WFRIMiner(iFile, _wFile, WS, regularity, sep='\t')[source]

Bases: _weightedFrequentRegularPatterns

Description:

WFRIMiner is one of the fundamental algorithm to discover weighted frequent regular patterns in a transactional database. * It stores the database in compressed WFRI-tree decreasing the memory usage and extracts the patterns from tree.It employs downward closure property to reduce the search space effectively.

Reference:

K. Klangwisan and K. Amphawan, “Mining weighted-frequent-regular itemsets from transactional database,” 2017 9th International Conference on Knowledge and Smart Technology (KST), 2017, pp. 66-71, doi: 10.1109/KST.2017.7886090.

Parameters:

iFile – str : Name of the Input file to mine complete set of Weighted Frequent Regular Patterns.
oFile – str : Name of the output file to store complete set of Weighted Frequent Regular Patterns.
sep – str : This variable is used to distinguish items from one another in a transaction. The default seperator is tab space. However, the users can override their default separator.
wFile – str : This is a weighted file.

Attributes:

iFilefile: Input file name or path of the input file
WS: float or int or str: The user can specify WS either in count or proportion of database size. If the program detects the data type of WS is integer, then it treats WS is expressed in count. Otherwise, it will be treated as float. Example: WS=10 will be treated as integer, while WS=10.0 will be treated as float
regularity: float or int or str: The user can specify regularity either in count or proportion of database size. If the program detects the data type of regularity is integer, then it treats regularity is expressed in count. Otherwise, it will be treated as float. Example: regularity=10 will be treated as integer, while regularity=10.0 will be treated as float
sepstr: This variable is used to distinguish items from one another in a transaction. The default separator is tab space or . However, the users can override their default separator.
oFilefile: Name of the output file or the path of the output file
startTime:float: To record the start time of the mining process
endTime:float: To record the completion time of the mining process
memoryUSSfloat: To store the total amount of USS memory consumed by the program
memoryRSSfloat: To store the total amount of RSS memory consumed by the program
Databaselist: To store the transactions of a database in list
mapSupportDictionary: To maintain the information of item and their frequency
lnoint: it represents the total no of transactions
treeclass: it represents the Tree class
finalPatternsdict: it represents to store the patterns

Methods:

mine(): Mining process will start from here
getPatterns(): Complete set of patterns will be retrieved with this function
save(oFile): Complete set of frequent patterns will be loaded in to an output file
getPatternsAsDataFrame(): Complete set of frequent patterns will be loaded in to a dataframe
getMemoryUSS(): Total amount of USS memory consumed by the mining process will be retrieved from this function
getMemoryRSS(): Total amount of RSS memory consumed by the mining process will be retrieved from this function
getRuntime(): Total amount of runtime taken by the mining process will be retrieved from this function
creatingItemSets(): Scans the dataset or dataframes and stores in list format
frequentOneItem(): Extracts the one-frequent patterns from transactions

Methods to execute code on terminal

Format:

(.venv) $ python3 WFRIMiner.py <inputFile> <outputFile> <weightSupport> <regularity>

Example Usage:

(.venv) $ python3 WFRIMiner.py sampleDB.txt patterns.txt 10 5

        .. note:: WS & regularity will be considered in support count or frequency

Importing this algorithm into a python program

from PAMI.weightedFrequentRegularpattern.basic import WFRIMiner as alg

obj = alg.WFRIMiner(iFile, WS, regularity)

obj.startMine()

weightedFrequentRegularPatterns = obj.getPatterns()

print("Total number of Frequent Patterns:", len(weightedFrequentRegularPatterns))

obj.save(oFile)

Df = obj.getPatternInDataFrame()

memUSS = obj.getMemoryUSS()

print("Total Memory in USS:", memUSS)

memRSS = obj.getMemoryRSS()

print("Total Memory in RSS", memRSS)

run = obj.getRuntime()

print("Total ExecutionTime in seconds:", run)

Credits:

The complete program was written by P.Likhitha under the supervision of Professor Rage Uday Kiran.

Mine() → None[source]: main program to start the operation :return: None

getMemoryRSS() → float[source]

Total amount of RSS memory consumed by the mining process will be retrieved from this function

Returns:: returning RSS memory consumed by the mining process
Return type:: float

getMemoryUSS() → float[source]

Total amount of USS memory consumed by the mining process will be retrieved from this function

Returns:: returning USS memory consumed by the mining process
Return type:: float

getPatterns() → Dict[str, float][source]

Function to send the set of frequent patterns after completion of the mining process

Returns:: returning frequent patterns
Return type:: dict

getPatternsAsDataFrame() → DataFrame[source]

Storing final frequent patterns in a dataframe

Returns:: returning frequent patterns in a dataframe
Return type:: pd.DataFrame

getRuntime() → float[source]

Calculating the total amount of runtime taken by the mining process

Returns:: returning total amount of runtime taken by the mining process
Return type:: float

printResults() → None[source]: This function is used to print the results :return: None

save(outFile: str) → None[source]

Complete set of frequent patterns will be loaded in to an output file

Parameters:: outFile (csv file) – name of the output file
Returns:: None

startMine() → None[source]: main program to start the operation :return: None