Untitled
unknown
python
a year ago
12 kB
2
Indexable
Never
import numpy as np import skfuzzy as fuzz import matplotlib.pyplot as plt from sys import exit import psutil, os import timeit import collections import copy import math from FuzzySubItem import FuzzySubItem from IndexList import IndexList from Item import Item from ListEntry import ListEntry from TemporaryTableEntry import TemporaryTableEntry internal_utility_start_limit = 1 internal_utility_end_limit = 10 external_utility_start_limit = 1 external_utility_end_limit = 10 external_utility = {} def get_membership_function(array, range_array): membership = [] for i in range(len(range_array) - 1): membership.append(fuzz.trimf(array, range_array[i])) membership.append(fuzz.trapmf(array, range_array[len(range_array) - 1])) return membership def process_memory(): process = psutil.Process(os.getpid()) mem_info = process.memory_info() return mem_info.rss def fuzzifier(value, membership_function, array): a = [] for i in range(len(membership_function)): a.append(fuzz.interp_membership(array, membership_function[i], value)) return a def getItemswithCount(fileName): filen = open(fileName) contents = filen.readlines() # open file & read lines transactionCount = len(contents) # number of lines = number of transactions # LinesToRead = math.floor(transactionCount * linePercent) # read 40% of trx # contents = contents[:LinesToRead] tfu_ = 0 # print("total Num qber of Transactions :", str(transactionCount), "considering trx : ", LinesToRead) transaction_list = [] for transaction in contents: assigned_transaction = [] transaction = transaction.strip().split() # split the transaction by space & get list of all items for item in transaction: # get the count of each items in the database item = int(item) tmp = np.random.randint(internal_utility_start_limit, internal_utility_end_limit) # count of each item assigned_transaction.append(Item(tmp, item)) if item not in external_utility.keys(): external_utility[item] = np.random.randint(external_utility_start_limit, external_utility_end_limit) transaction_list.append(assigned_transaction) return transaction_list def convert_to_dict_list(transactions, membership, per_trx_mtfu_List, per_trx_tfu_List): dict_list = [] for transaction in transactions: transaction_dict = [] trxutil = 0 tfu_util = 0 for item in transaction: fuzzified = fuzzifier(item.quantity, membership, x_a_b_f_g) fuzzifiedmult = [i * external_utility[item.name] * item.quantity for i in fuzzified] mtfu_i = max(fuzzifiedmult) trxutil += mtfu_i tfu_util = tfu_util + sum(fuzzifiedmult) for idx, value in enumerate(fuzzifiedmult): if value != 0: fuzzy_type = "low" if idx == 0 else "medium" if idx == 1 else "high" transaction_dict.append(FuzzySubItem(item.quantity, item.name, fuzzy_type, fuzzified[idx], external_utility[item.name] * item.quantity, mtfu_i)) # transaction_dict[item.name] = fuzzified dict_list.append(transaction_dict) per_trx_mtfu_List.append(trxutil) per_trx_tfu_List.append(tfu_util) return dict_list, per_trx_mtfu_List, per_trx_tfu_List def print_dict_list(transactions): dict_list = [] for transaction in transactions: transaction_dict = {} for item in transaction: transaction_dict[item.name] = item.quantity dict_list.append(transaction_dict) return dict_list def print_fuzzy_transaction_details(transactions): for idx, transaction in enumerate(transactions, start=1): print(f'Transaction {idx}:') for item in transaction: print(f' Item Name: {item.name}') print(f' Fuzzy Value: {item.fuzzy_value}') print(f' Fuzzy Type: {item.type}') print(f' Fuzzy Quantity: {item.quantity}') print(f' Fuzzy Utility: {item.utility}') print(f' Max Fuzzy Utility: {item.get_mtfu()}') print('---') def multiply_previous_utility(entries, fraction): for entry in entries: entry.utility *= fraction def multiply_dict_values(dictionary, fraction): for key in dictionary: dictionary[key] *= fraction def create_index_lists(transactions, index_lists, dfuub_list, decaying_factor, per_transaction_mtfu): for j in range(len(transactions)): for i, item in enumerate(transactions[j]): transaction = transactions[j] entry = ListEntry(None, None, item.fuzzy_value, item.utility, item.get_mtfu()) if i < len(transaction) - 1: next_item_name = transaction[i + 1].name next_item_type = transaction[i + 1].get_type() key = f"{next_item_name}_{next_item_type}" entry.nextItem = transaction[i + 1] if key in index_lists: entry.nextInd = len(index_lists[key].entries) else: entry.nextInd = 0 key = f"{item.name}_{item.get_type()}" if key not in index_lists: index_lists[key] = IndexList(key, []) dfuub_list[key] = 0 if index_lists[key].entries: multiply_previous_utility(index_lists[key].entries, decaying_factor) multiply_dict_values(dfuub_list, decaying_factor) index_lists[key].entries.append(entry) dfuub_list[key] += per_transaction_mtfu[j] def print_index_list_attributes(index_list): print(f'Index List Name: {index_list.name}') # print(f'Total Utility: {index_list.total}') # print(f'Remaining Utility: {index_list.remaining}') print(f'Entries:') for entry in index_list.entries: print(f' Next Item: {entry.nextItem}') print(f' Next Index: {entry.nextInd}') print(f' Fuzzy Value: {entry.fuzzyValue}') print(f' Utility: {entry.utility}') print(f' mtfu: {entry.mtfu}') print('---') def sorted_dictionary(dict): keys = list(dict.keys()) values = list(dict.values()) sorted_value_index = np.argsort(values) sorted_dict = {keys[i]: values[i] for i in sorted_value_index} return sorted_dict def restructuring(index_lists, dfuub_lists): sorted_index_lists = dict( sorted(index_lists.items(), reverse=True, key=lambda item: list(dfuub_lists.keys()).index(item[0]))) regenerated_transactions = [] traxes = [] # print(sorted_index_lists) for index_list in index_lists.values(): for i in range(len(index_list.entries)): initial_entry = None if index_list.entries and index_list.entries[i].get_visited() is not True: initial_entry = index_list.entries[i] else: continue regenerated_transaction, item_curr_ind, trax = regenerate(index_list, initial_entry, index_lists, i) regenerated_transactions.append(regenerated_transaction) traxes.append(trax) print(index_list.name) print(item_curr_ind) print(traxes) # def traverse_and_regenerate(index_list, initial_entry, index_lists, start_ind): # current_entry = initial_entry # regenerated_transaction = [] # trax = [] # if current_entry.get_visited() is not True: # regenerated_transaction.append( # TemporaryTableEntry(index_list.name, current_entry.nextItem, current_entry.nextInd)) # trax.append(index_list.name) # item_curr_ind = {} # item_curr_ind[index_list.name] = start_ind # # while current_entry is not None: # current_entry.set_visited(True) # fuzzy_value = current_entry.fuzzyValue # utility = current_entry.utility # next_item = current_entry.nextItem # next_index = current_entry.nextInd # # # regenerated_transaction.append(current_entry.name) # if next_item is not None: # key = f"{next_item.name}_{next_item.type}" # # regenerated_transaction.append(key) # # current_entry = index_list.entries[current_entry.nextInd] # if index_lists[key].entries[current_entry.nextInd].get_visited is not True: # item_curr_ind[key] = current_entry.nextInd # current_entry = index_lists[key].entries[current_entry.nextInd] # regenerated_transaction.append( # TemporaryTableEntry(key, current_entry.nextItem, current_entry.nextInd)) # trax.append(key) # # # else: # current_entry = None # else: # current_entry = None # # return regenerated_transaction, item_curr_ind, trax def regenerate(index_list, initial_entry, index_lists, start_index): current_entry = initial_entry regenerated_transaction = [] item_curr_ind = {} trax = [] name = index_list.name cur_ind = start_index # if current_entry.get_visited() is not True: # regenerated_transaction.append( # TemporaryTableEntry(index_list.name, current_entry.nextItem, current_entry.nextInd)) # trax.append(index_list.name) # while current_entry is not None: if current_entry.get_visited() is not True: current_entry.set_visited(True) fuzzy_value = current_entry.fuzzyValue utility = current_entry.utility next_item = current_entry.nextItem next_index = current_entry.nextInd regenerated_transaction.append( TemporaryTableEntry(name, current_entry.nextItem, current_entry.nextInd)) trax.append(name) item_curr_ind[name] = cur_ind # regenerated_transaction.append(current_entry.name) if next_item is not None: key = f"{next_item.name}_{next_item.type}" # regenerated_transaction.append(key) # current_entry = index_list.entries[current_entry.nextInd] current_entry = index_lists[key].entries[current_entry.nextInd] name = key cur_ind = current_entry.nextInd else: current_entry = None else: current_entry = None return regenerated_transaction, item_curr_ind, trax def process_tempArray(regenerated_trx, item_curr_index,index_lists): pass if __name__ == '__main__': range_array = [[0, 2, 4], [2, 4, 6], [4, 6, 50, 50]] x_a_b_f_g = np.arange(0, 50, 1) percent = 0.02 decaying_factor = 0.5 membership = get_membership_function(x_a_b_f_g, range_array) transaction_list = getItemswithCount("test.dat") print(print_dict_list(transaction_list)) per_trx_mtfu_List = [] per_trx_tfu_List = [] index_lists = {} dfuub_list = {} fuzzi_region_value_list, per_trx_mtfu_List, per_trx_tfu_List = convert_to_dict_list(transaction_list, membership, per_trx_mtfu_List, per_trx_tfu_List) # print(len(fuzzi_region_value_list)) # print(print_fuzzy_transaction_details(fuzzi_region_value_list)) # print(per_trx_mtfu_List) # print(per_trx_tfu_List) tfu = sum(per_trx_tfu_List) minutil = percent * tfu print(external_utility) print(minutil) create_index_lists(fuzzi_region_value_list, index_lists, dfuub_list, decaying_factor, per_trx_mtfu_List) print("Lists : \n\n\n") for index_list in index_lists.values(): print_index_list_attributes(index_list) print("\n\n\ntotal lists : ", len(index_lists)) print(per_trx_mtfu_List) dfuub_list = sorted_dictionary(dfuub_list) print(dfuub_list) restructuring(index_lists, dfuub_list)