Merge pull request #578 from LasyaPalla/main

reverted minor changes

Author: udayRage

PAMI/highUtilityPattern/basic/efimParallel.py

@@ -225,7 +225,7 @@ def _read_file(self):
         twu = {k: v for k, v in twu.items() if v >= self.minUtil}
 
         # Sort TWU items by utility
-        twu = {k: v for k, v in sorted(twu.items(), key=lambda item_: item_[1], reverse=True)}
+        twu = {k: v for k, v in sorted(twu.items(), key=lambda item: item[1], reverse=True)}
 
         strToInt = {}
         t = len(twu)
@@ -285,7 +285,7 @@ def _binarySearch(self, arr, item):
 
         low = 0
         high = len(arr) - 1
-        #mid = 0
+        mid = 0
 
         while low <= high:
             mid = (high + low) // 2
@@ -337,7 +337,7 @@ def _project(self, beta, file_data, secondary):
         item = beta[-1]
 
         temp = [v for k, v in file_data.items() if item in k]
-        #start = time.time()
+        start = time.time()
 
         for v in temp:
             index = self._binarySearch(v[0], item)

PAMI/highUtilityPattern/parallel/efimparallel.py

@@ -131,11 +131,11 @@ class efimParallel(_ab._utilityPatterns):
 
     def __init__(self, iFile, minUtil, sep="\t", threads=1):
         super().__init__(iFile, minUtil, sep)
-        self.runtime = None
-        self.oFile = None
-        self.start = None
-        self.memoryUSS = None
-        self.memoryRSS = None
+        # self.runtime = None
+        # self.oFile = None
+        # self.start = None
+        # self.memoryUSS = None
+        # self.memoryRSS = None
         self.inputFile = iFile
         self.minUtil = minUtil
         self.sep = sep
@@ -182,7 +182,7 @@ def _read_file(self):
         twu = {k: v for k, v in twu.items() if v >= self.minUtil}
 
         # Sort TWU items by utility
-        twu = {k: v for k, v in sorted(twu.items(), key=lambda item_: item_[1], reverse=True)}
+        twu = {k: v for k, v in sorted(twu.items(), key=lambda item: item[1], reverse=True)}
 
         strToInt = {}
         t = len(twu)
@@ -248,7 +248,7 @@ def _binarySearch(self, arr, item):
 
         low = 0
         high = len(arr) - 1
-        #mid = 0
+        mid = 0
 
         while low <= high:
             mid = (high + low) // 2
@@ -297,7 +297,7 @@ def _project(self, beta, file_data, secondary):
         item = beta[-1]
 
         temp = [v for k, v in file_data.items() if item in k]
-        #start = time.time()
+        start = time.time()
 
         for v in temp:
             index = self._binarySearch(v[0], item)

PAMI/highUtilityPatterns/parallel/GPUEFIM.py

@@ -190,16 +190,16 @@ class GPUEFIM:
    """
 
     def __init__(self, inputFile, minUtil, sep = '\t'):
-        self.runtime = None
-        self.memoryUSS = None
-        self.memoryRSS = None
-        self.start = None
-        self.numTransactions = None
-        self.indexesEnd = None
-        self.secondaryLen = None
-        self.indexesStart = None
-        self.utils = None
-        self.items = None
+        # self.runtime = None
+        # self.memoryUSS = None
+        # self.memoryRSS = None
+        # self.start = None
+        # self.numTransactions = None
+        # self.indexesEnd = None
+        # self.secondaryLen = None
+        # self.indexesStart = None
+        # self.utils = None
+        # self.items = None
         self.inputFile = inputFile
         self.minUtil = minUtil
         self.sep = sep
@@ -221,8 +221,8 @@ def read_file(self):
         file_data = []
         twu = {}
 
-        with open(self.inputFile, 'r') as file:
-            fd = mmap.mmap(file.fileno(), 0, prot=mmap.PROT_READ)
+        with open(self.inputFile, 'r') as f:
+            fd = mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ)
 
             for line in iter(fd.readline, b""):
                 line = line.decode('utf-8').strip().split(":")
@@ -244,7 +244,7 @@ def read_file(self):
         twu = {k: v for k, v in twu.items() if v >= self.minUtil}
 
         # Sort TWU items by utility
-        twu = {k: v for k, v in sorted(twu.items(), key=lambda item_: item_[1], reverse=True)}
+        twu = {k: v for k, v in sorted(twu.items(), key=lambda item: item[1], reverse=True)}
 
         strToInt = {}
         t = len(twu)
@@ -417,10 +417,10 @@ def save(self, outputFile):
         :param outputFile: name of the output file
         :type outputFile: csv file
         """
-        with open(outputFile, 'w') as file_:
+        with open(outputFile, 'w') as f:
             for key, value in self.Patterns.items():
                 joined = " ".join(key) + " #UTIL: " + str(value) + "\n"
-                file_.write(joined)
+                f.write(joined)
 
     @deprecated("It is recommended to use 'mine()' instead of 'mine()' for mining process. Starting from January 2025, 'mine()' will be completely terminated.")
     def startMine(self):

PAMI/highUtilityPatternsInStreams/HUPMS.py

@@ -884,7 +884,7 @@ def getPatternsAsDataFrame(self):
         :rtype: pandas.DataFrame
         """
 
-        #dataframe = {}
+        dataframe = {}
         data = []
         for x, y in self.__finalPatterns.items():
             for pattern in y:

PAMI/highUtilityPatternsInStreams/SHUGrowth.py

@@ -674,12 +674,12 @@ def createPrefixBranch(self, root):
 
         chosenItemset = stack[0]
         lastUtil = sum(chosenItemset.utility)
-        #curBacthes = [i for i, e in enumerate(chosenItemset.utility) if e != 0]
+        curBacthes = [i for i, e in enumerate(chosenItemset.utility) if e != 0]
 
         otherUtilites = []
 
         for i in range(1, len(stack)-1):
-            #curItemset = stack[i]
+            curItemset = stack[i]
             epu = lastUtil
 
             for j in range(i-1, 0, -1):
@@ -968,7 +968,7 @@ def getPatternsAsDataFrame(self):
         :rtype: pandas.DataFrame
         """
 
-        #dataframe = {}
+        dataframe = {}
         data = []
         for x, y in self.__finalPatterns.items():
             for pattern in y:

PAMI/highUtilitySpatialPattern/basic/HDSHUIM.py

@@ -293,7 +293,7 @@ class HDSHUIM(_ab._utilityPatterns):
 
     def __init__(self, iFile: str, nFile: str, minUtil: int, sep: str="\t") -> None:
         super().__init__(iFile, nFile, minUtil, sep)
-        self.oFile = None
+        #self.oFile = None
         self._startTime = 0
         self._endTime = 0
         self._huiCount = 0
@@ -344,37 +344,37 @@ def mine(self) -> None:
             for line in file1:
                 line = line.split("\n")[0]
                 parts = line.split(self._sep)
-                parts = [i_.strip() for i_ in parts]
+                parts = [i.strip() for i in parts]
                 item = parts[0]
                 neigh1 = list()
-                for j in range(1, len(parts)):
-                    neigh1.append(parts[j])
+                for i in range(1, len(parts)):
+                    neigh1.append(parts[i])
                 self._neighbors[item] = set(neigh1)
         with open(self._iFile, 'r') as file:
             for line in file:
                 parts = line.split(":")
                 itemString = (parts[0].split("\n")[0]).split(self._sep)
                 utilityString = (parts[2].split("\n")[0]).split(self._sep)
-                #transUtility = int(parts[1])
+                transUtility = int(parts[1])
                 trans1 = set()
-                for j in range(0, len(itemString)):
-                    trans1.add(itemString[j])
-                for j in range(0, len(itemString)):
-                    item = itemString[j]
+                for i in range(0, len(itemString)):
+                    trans1.add(itemString[i])
+                for i in range(0, len(itemString)):
+                    item = itemString[i]
                     twu = self._mapOfPMU.get(item)
                     if twu is None:
-                        twu = int(utilityString[j])
+                        twu = int(utilityString[i])
                     else:
-                        twu += int(utilityString[j])
+                        twu += int(utilityString[i])
                     self._mapOfPMU[item] = twu
                     if self._neighbors.get(item) is None:
                         continue
                     neighbours2 = trans1.intersection(self._neighbors.get(item))
                     for item2 in neighbours2:
                         if self._mapOfPMU.get(item2) is None:
-                            self._mapOfPMU[item2] = int(utilityString[j])
+                            self._mapOfPMU[item2] = int(utilityString[i])
                         else:
-                            self._mapOfPMU[item2] += int(utilityString[j])
+                            self._mapOfPMU[item2] += int(utilityString[i])
 
         listOfCUList = []
         hashTable = {}
@@ -395,10 +395,10 @@ def mine(self) -> None:
                 newTwu = 0
                 txKey = []
                 revisedTrans = []
-                for j in range(0, len(items)):
+                for i in range(0, len(items)):
                     pair = _Pair()
-                    pair.item = items[j]
-                    pair.utility = int(utilities[j])
+                    pair.item = items[i]
+                    pair.utility = int(utilities[i])
                     if self._mapOfPMU.get(pair.item) >= minUtil:
                         revisedTrans.append(pair)
                         txKey.append(pair.item)
@@ -408,35 +408,35 @@ def mine(self) -> None:
                 if len(revisedTrans) > 0:
                     if txKey1 not in hashTable.keys():
                         hashTable[txKey1] = len(mapItemsToCUList[revisedTrans[len(revisedTrans) - 1].item].elements)
-                        for j in range(len(revisedTrans) - 1, -1, -1):
-                            pair = revisedTrans[j]
+                        for i in range(len(revisedTrans) - 1, -1, -1):
+                            pair = revisedTrans[i]
                             cuListOfItems = mapItemsToCUList.get(pair.item)
                             element = _Element(ts, pair.utility, ru, 0, 0)
-                            if j > 0:
-                                element.prevPos = len(mapItemsToCUList[revisedTrans[j - 1].item].elements)
+                            if i > 0:
+                                element.prevPos = len(mapItemsToCUList[revisedTrans[i - 1].item].elements)
                             else:
                                 element.prevPos = -1
                             cuListOfItems.addElements(element)
                             ru += pair.utility
                     else:
                         pos = hashTable[txKey1]
                         ru = 0
-                        for j in range(len(revisedTrans) - 1, -1, -1):
-                            cuListOfItems = mapItemsToCUList[revisedTrans[j].item]
-                            cuListOfItems.elements[pos].snu += revisedTrans[j].utility
+                        for i in range(len(revisedTrans) - 1, -1, -1):
+                            cuListOfItems = mapItemsToCUList[revisedTrans[i].item]
+                            cuListOfItems.elements[pos].snu += revisedTrans[i].utility
                             cuListOfItems.elements[pos].remainingUtility += ru
-                            cuListOfItems.sumSnu += revisedTrans[j].utility
+                            cuListOfItems.sumSnu += revisedTrans[i].utility
                             cuListOfItems.sumRemainingUtility += ru
-                            ru += revisedTrans[j].utility
+                            ru += revisedTrans[i].utility
                             pos = cuListOfItems.elements[pos].prevPos
                 # EUCS
-                for j in range(len(revisedTrans) - 1, -1, -1):
-                    pair = revisedTrans[j]
+                for i in range(len(revisedTrans) - 1, -1, -1):
+                    pair = revisedTrans[i]
                     mapFMAPItem = self._mapFMAP.get(pair.item)
                     if mapFMAPItem is None:
                         mapFMAPItem = {}
                         self._mapFMAP[pair.item] = mapFMAPItem
-                    for j in range(j + 1, len(revisedTrans)):
+                    for j in range(i + 1, len(revisedTrans)):
                         pairAfter = revisedTrans[j]
                         twuSUm = mapFMAPItem.get(pairAfter.item)
                         if twuSUm is None:
@@ -467,19 +467,19 @@ def _ExploreSearchTree(self, prefix: List[str], uList: List[_CUList], exNeighbou
         :type minUtil:int
         :return: None
         """
-        for k in range(0, len(uList)):
-            x = uList[k]
+        for i in range(0, len(uList)):
+            x = uList[i]
             if x.item not in exNeighbours:
                 continue
             self._candidates += 1
-            #sortedPrefix = [0] * (len(prefix) + 1)
+            sortedPrefix = [0] * (len(prefix) + 1)
             sortedPrefix = prefix[0:len(prefix) + 1]
             sortedPrefix.append(x.item)
             if (x.sumSnu + x.sumCu >= minUtil) and (x.item in exNeighbours):
                 self._saveItemSet(prefix, len(prefix), x.item, x.sumSnu + x.sumCu)
             if x.sumSnu + x.sumCu + x.sumRemainingUtility + x.sumCru >= minUtil:  # U-Prune # and (x.item in exNeighbours)):
                 ULIST = []
-                for j in range(k, len(uList)):
+                for j in range(i, len(uList)):
                     if (uList[j].item in exNeighbours) and (self._neighbors.get(x.item) is not None) and (
                             uList[j].item in self._neighbors.get(x.item)):
                         ULIST.append(uList[j])
@@ -512,8 +512,8 @@ def _constructCUL(self, x: _Element, compactUList: List[_CUList], st: int, minUt
         lau = []
         cUtil = []
         eyTs = []
-        for i__ in range(0, len(compactUList)):
-            uList = _CUList(compactUList[i__].item)
+        for i in range(0, len(compactUList)):
+            uList = _CUList(compactUList[i].item)
             exCul.append(uList)
             lau.append(0)
             cUtil.append(0)
@@ -558,12 +558,12 @@ def _constructCUL(self, x: _Element, compactUList: List[_CUList], st: int, minUt
                 newT1 = tuple(newT)
                 if newT1 not in hashTable.keys():
                     hashTable[newT1] = len(exCul[newT[len(newT) - 1]].elements)
-                    for i__ in range(len(newT) - 1, -1, -1):
-                        cuListOfItems = exCul[newT[i__]]
-                        y = compactUList[newT[i__]].elements[eyTs[newT[i__]]]
+                    for i in range(len(newT) - 1, -1, -1):
+                        cuListOfItems = exCul[newT[i]]
+                        y = compactUList[newT[i]].elements[eyTs[newT[i]]]
                         element = _Element(ex.ts, ex.snu + y.snu - ex.pu, ru, ex.snu, 0)
-                        if i__ > 0:
-                            element.prevPos = len(exCul[newT[i__ - 1]].elements)
+                        if i > 0:
+                            element.prevPos = len(exCul[newT[i - 1]].elements)
                         else:
                             element.prevPos = -1
                         cuListOfItems.addElements(element)
@@ -660,8 +660,8 @@ def _saveItemSet(self, prefix: List[str], prefixLen: int, item: str, utility: in
         """
         self._huiCount += 1
         res = str()
-        for _ in range(0, prefixLen):
-            res += str(prefix[_]) + "\t"
+        for i in range(0, prefixLen):
+            res += str(prefix[i]) + "\t"
         res += str(item)
         res1 = str(utility)
         self._finalPatterns[res] = res1