Untitled

mail@pastecode.io avatar
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)