local periodic patterns

Author: charan-teja2003

PAMI/localPeriodicPattern/basic/LPPGrowth.py

@@ -8,37 +8,39 @@
 # **Importing this algorithm into a python program**
 # --------------------------------------------------------
 #
-#     from PAMI.localPeriodicPattern.basic import LPPGrowth as alg
+#             from PAMI.localPeriodicPattern.basic import LPPGrowth as alg
 #
-#     obj = alg.LPPGrowth(iFile, maxPer, maxSoPer, minDur)
+#             obj = alg.LPPGrowth(iFile, maxPer, maxSoPer, minDur)
 #
-#     obj.startMine()
+#             obj.mine()
 #
-#     localPeriodicPatterns = obj.getPatterns()
+#             localPeriodicPatterns = obj.getPatterns()
 #
-#     print(f'Total number of local periodic patterns: {len(localPeriodicPatterns)}')
+#             print(f'Total number of local periodic patterns: {len(localPeriodicPatterns)}')
 #
-#     obj.save(oFile)
+#             obj.save(oFile)
 #
-#     Df = obj.getPatternsAsDataFrame()
+#             Df = obj.getPatternsAsDataFrame()
 #
-#     memUSS = obj.getMemoryUSS()
+#             memUSS = obj.getMemoryUSS()
 #
-#     print(f'Total memory in USS: {memUSS}')
+#             print(f'Total memory in USS: {memUSS}')
 #
-#     memRSS = obj.getMemoryRSS()
+#             memRSS = obj.getMemoryRSS()
 #
-#     print(f'Total memory in RSS: {memRSS}')
+#             print(f'Total memory in RSS: {memRSS}')
 #
-#     runtime = obj.getRuntime()
-#
-#     print(f'Total execution time in seconds: {runtime})
+#             runtime = obj.getRuntime()
 #
+#             print(f'Total execution time in seconds: {runtime})
 #
 
 
+
+
+
 __copyright__ = """
- Copyright (C)  2021 Rage Uday Kiran
+Copyright (C)  2021 Rage Uday Kiran
 
      This program is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
@@ -60,6 +62,7 @@
 
 from PAMI.localPeriodicPattern.basic import abstract as _ab
 from typing import List, Dict, Tuple, Set, Union, Any, Generator
+from deprecated import deprecated
 
 class Node:
     """
@@ -94,8 +97,14 @@ def __init__(self) -> None:
     def getChild(self, item: int) -> 'Node':
         """
         This function is used to get child node from the parent node
-        :param item:
+
+        :param item: item of the parent node
+
+        :type item: int
+
         :return: if node have node of item, then return it. if node don't have return []
+
+        :rtype: Node
         """
         for child in self.child:
             if child.item == item:
@@ -141,6 +150,7 @@ def addTransaction(self, transaction: List[int], tid: int) -> None:
         :type transaction: list
         :param tid: represents the timestamp of transaction
         :type tid: list or int
+        :return: None
         """
         current = self.root
         for item in transaction:
@@ -164,6 +174,7 @@ def fixNodeLinks(self, item: int, newNode: 'Node') -> None:
         :type item: string
         :param newNode: it represents node which is added
         :type newNode: Node
+        :return: None
         """
         if item in self.nodeLinks:
             lastNode = self.nodeLinks[item]
@@ -178,6 +189,7 @@ def deleteNode(self, item: int) -> None:
 
         :param item: it represents the item name of node
         :type item: str
+        :return: None
         """
         deleteNode = self.firstNodeLink[item]
         parentNode = deleteNode.parent
@@ -203,6 +215,7 @@ def createPrefixTree(self, path: List[int], tidList: List[int]) -> None:
         :type path: list
         :param tidList: it represents tid of each item
         :type tidList: list
+        :return: None
         """
         currentNode = self.root
         for item in path:
@@ -235,9 +248,9 @@ class LPPGrowth(_ab._localPeriodicPatterns):
         a Discrete Sequence. Information Sciences, Elsevier, to appear. [ppt] DOI: 10.1016/j.ins.2020.09.044
 
     :param  iFile: str :
-                   Name of the Input file to mine complete set of frequent pattern's
+                   Name of the Input file to mine complete set of local periodic pattern's
     :param  oFile: str :
-                   Name of the output file to store complete set of frequent patterns
+                   Name of the output file to store complete set of local periodic patterns
     :param  minDur: str:
                    Minimal duration in seconds between consecutive periods of time-intervals where a pattern is continuously periodic.
     :param  maxPer: float:
@@ -299,7 +312,7 @@ class LPPGrowth(_ab._localPeriodicPatterns):
                 Calculate PTL from input tsList as integer list.
             calculatePTLbit(tsList)
                 Calculate PTL from input tsList as bit vector.
-            startMine()
+            mine()
                 Mining process will start from here.
             getMemoryUSS()
                 Total amount of USS memory consumed by the mining process will be retrieved from this function.
@@ -315,12 +328,19 @@ class LPPGrowth(_ab._localPeriodicPatterns):
                 Complete set of local periodic patterns will be loaded in to a dataframe.
 
     **Executing the code on terminal:**
-    -------------------------------------
-            Format:
-                    >>> python3 LPPMGrowth.py <inputFile> <outputFile> <maxPer> <minSoPer> <minDur>
+    ---------------------------------------
+
+    .. code-block:: console
+
+      Format:
 
-            Examples:
-                    >>> python3 LPPMGrowth.py sampleDB.txt patterns.txt 0.3 0.4 0.5
+      (.venv) $ python3 LPPMGrowth.py <inputFile> <outputFile> <maxPer> <minSoPer> <minDur>
+
+      Example Usage:
+
+      (.venv) $ python3 LPPMGrowth.py sampleDB.txt patterns.txt 0.3 0.4 0.5
+
+    .. note: minDur will be considered as time interval between two consecutive periods
 
 
     **Sample run of importing the code:**
@@ -331,7 +351,7 @@ class LPPGrowth(_ab._localPeriodicPatterns):
 
             obj = alg.LPPGrowth(iFile, maxPer, maxSoPer, minDur)
 
-            obj.startMine()
+            obj.mine()
 
             localPeriodicPatterns = obj.getPatterns()
 
@@ -585,6 +605,7 @@ def __patternGrowth(self, tree: 'Tree', prefix: List[int], prefixPFList: Dict[An
         :type prefix: list
         :param prefixPFList: tsList of prefix patterns.
         :type prefixPFList: dict or list
+        :return: None
         """
         items = list(prefixPFList)
         if not prefix:
@@ -641,6 +662,7 @@ def __calculatePTL(self, tsList: List[int]) -> set:
         :param tsList: It is tsList which store time stamp as integer.
         :type tsList: list
         :return: PTL
+        :rtype: set
         """
         start = -1
         PTL = set()
@@ -674,6 +696,7 @@ def __calculatePTLbit(self, tsList: List[int]) -> set:
         :param tsList: It is tsList which store time stamp as bit vector.
         :type tsList: list
         :return: PTL
+        :rtype: set
         """
         tsList = list(bin(tsList))
         tsList = tsList[2:]
@@ -720,7 +743,9 @@ def __convert(self, value: Any) -> float:
         to convert the type of user specified minSup value
 
         :param value: user specified minSup value
+        :type value: int or float or str
         :return: converted type
+        :rtype: float
         """
         if type(value) is int:
             value = int(value)
@@ -734,6 +759,7 @@ def __convert(self, value: Any) -> float:
                 value = int(value)
         return value
 
+    @deprecated("It is recommended to use 'mine()' instead of 'startMine()' for mining process. Starting from January 2025, 'startMine()' will be completely terminated.")
     def startMine(self) -> None:
         """
         Mining process start from here.
@@ -755,8 +781,30 @@ def startMine(self) -> None:
         self._localPeriodicPatterns__memoryUSS = process.memory_full_info().uss
         self._localPeriodicPatterns__memoryRSS = process.memory_info().rss
 
+    def mine(self) -> None:
+        """
+        Mining process start from here.
+        """
+        self._localPeriodicPatterns__startTime = _ab._time.time()
+        self._localPeriodicPatterns__finalPatterns = {}
+        self.__creatingItemSets()
+        self._localPeriodicPatterns__maxPer = self.__convert(self._localPeriodicPatterns__maxPer)
+        self._localPeriodicPatterns__maxSoPer = self.__convert(self._localPeriodicPatterns__maxSoPer)
+        self._localPeriodicPatterns__minDur = self.__convert(self._localPeriodicPatterns__minDur)
+        self.__createTSList()
+        self.__generateLPP()
+        self.__createLPPTree()
+        self.__patternGrowth(self.__root, [], self.__items)
+        self._localPeriodicPatterns__endTime = _ab._time.time()
+        process = _ab._psutil.Process(_ab._os.getpid())
+        self._localPeriodicPatterns__memoryUSS = float()
+        self._localPeriodicPatterns__memoryRSS = float()
+        self._localPeriodicPatterns__memoryUSS = process.memory_full_info().uss
+        self._localPeriodicPatterns__memoryRSS = process.memory_info().rss
+
     def getMemoryUSS(self) -> float:
-        """Total amount of USS memory consumed by the mining process will be retrieved from this function
+        """
+        Total amount of USS memory consumed by the mining process will be retrieved from this function
 
         :return: returning USS memory consumed by the mining process
         :rtype: float
@@ -765,7 +813,8 @@ def getMemoryUSS(self) -> float:
         return self._localPeriodicPatterns__memoryUSS
 
     def getMemoryRSS(self) -> float:
-        """Total amount of RSS memory consumed by the mining process will be retrieved from this function
+        """
+        Total amount of RSS memory consumed by the mining process will be retrieved from this function
 
         :return: returning RSS memory consumed by the mining process
         :rtype: float
@@ -774,7 +823,8 @@ def getMemoryRSS(self) -> float:
         return self._localPeriodicPatterns__memoryRSS
 
     def getRuntime(self) -> float:
-        """Calculating the total amount of runtime taken by the mining process
+        """
+        Calculating the total amount of runtime taken by the mining process
 
         :return: returning total amount of runtime taken by the mining process
         :rtype: float
@@ -783,7 +833,8 @@ def getRuntime(self) -> float:
         return self._localPeriodicPatterns__endTime - self._localPeriodicPatterns__startTime
 
     def getPatternsAsDataFrame(self) -> '_ab._pd.DataFrame':
-        """Storing final local periodic patterns in a dataframe
+        """
+        Storing final local periodic patterns in a dataframe
 
         :return: returning local periodic patterns in a dataframe
         :rtype: pd.DataFrame
@@ -805,6 +856,7 @@ def save(self, outFile: str) -> None:
 
         :param outFile: name of the output file
         :type outFile: csv file
+        :return: None
         """
         self._localPeriodicPatterns__oFile = outFile
         writer = open(self._localPeriodicPatterns__oFile, 'w+')
@@ -819,7 +871,8 @@ def save(self, outFile: str) -> None:
             writer.write("%s \n" % patternsAndPTL)
 
     def getPatterns(self) -> Dict:
-        """ Function to send the set of local periodic patterns after completion of the mining process
+        """
+        Function to send the set of local periodic patterns after completion of the mining process
 
         :return: returning frequent patterns
         :rtype: dict
@@ -844,6 +897,7 @@ def printResults(self) -> None:
         if len(_ab._sys.argv) == 5:
             _ap = LPPGrowth(_ab._sys.argv[1], _ab._sys.argv[3], float(_ab._sys.argv[4]))
         _ap.startMine()
+        _ap.mine()
         print("Total number of Local Periodic Patterns:", len(_ap.getPatterns()))
         _ap.save(_ab._sys.argv[2])
         print("Total Memory in USS:", _ap.getMemoryUSS())