Instructions¶ 1. This note book contains instructions for COMP9318-Lab2. 2. You are required to complete your implementation in a file submission.py provided along with this notebook. 3. You are only allowed to use Python 3.6 for implementation. 4. You are not allowed to print out unnecessary stuff. We will not consider any output printed out on the screen. All results should be returned in appropriate data structures return by corresponding functions. 5. You need to submit the code for Lab2 via following link: https://kg.cse.unsw.edu.au/submit/ 6. For each question, we have provided you with detailed instructions along with question headings. In case of any problem, you can post your query @ Piazza. 7. If you choose to skip a question, leave the corresponding function body as it is (i.e., keep the pass line), otherwise it may affect your mark for other questions. 8. You are allowed to add other functions and/or import additional modules (you may have to in this lab), but you are not allowed to define global variables. Only functions are allowed in submission.py. 9. You should not import unnecessary modules/libraries, failing to import such modules at test time will lead to errors. 10. We will provide immediate feedback on your submission. You can access your scores using the online submission portal on the same day. 11. For Final Evaluation we will be using a different dataset, so your final scores may vary. 12. You are allowed to submit as many times as you want before the deadline, but ONLY the latest version will be kept and marked. 13. Submission deadline for this assignment is 20:59:59 on 23rd March, 2020 (Sydney Time). We will not accept any late submissions. Question 1: Optimized BUC algorithm (100 points) You need to implement the full buc_rec_optimized algorithm with the single-tuple optimization (as described below). Given an input dataframe: A B M 1 2 100 2 1 20 Invoking buc_rec_optimized on this data will result in following dataframe: A B M 1 2 100 1 ALL 100 2 1 20 2 ALL 20 ALL 1 20 ALL 2 100 ALL ALL 120 We have pre-defined the function buc_rec_optimized in the file submission.py, and its helper functions are defined in the file helper.py. Note: You should use the functions defined in the file helper.py, you are not allowed to change this file. We will provide this file in the test environment. Input and output Both input and output are dataframes. The input dataframe (i.e., the base cuboid) is directly generated from the input file. Given the dimensionality of the base cuboid is d, each row is like: v_1 v_2 … v_d m where v_i is the cell’s value on the i-th dimension, and m is the measure value. The output dataframe contains n rows, each for a non-empty cell in the compute data cube derived from the input base cuboid. Each row is formatted like input: v_1 v_2 … v_d m where v_i is the cell’s value on the i-th dimension, and m is the measure value. The single-tuple optimization Consider the naive way of recursive implementation of the BUC algorithm, you will notice that it uses several recursive calls to compute all the derived results from an input that consists of only one tuple. This is certainly a waste of computation. For example, if we are asked to compute the cube given the following input B C M 1 2 100 We can immmediately output the following, without using any recursive calls. 1 2 100 * 2 100 1 * 100 * * 100 ** Note: For lab-2, you are allowed to use only two libraries, i.e., pandas, and numpy.** In [1]: import pandas as pd import numpy as np In [2]: ##============================================================ # Data file format: # * tab-delimited input file # * 1st line: dimension names and the last dimension is assumed to be the measure # * rest of the lines: data values. def read_data(filename): df = pd.read_csv(filename, sep=’\t’) return (df) # helper functions def project_data(df, d): # Return only the d-th column of INPUT return df.iloc[:, d] def select_data(df, d, val): # SELECT * FROM INPUT WHERE input.d = val col_name = df.columns[d] return df[df[col_name] == val] def remove_first_dim(df): # Remove the first dim of the input return df.iloc[:, 1:] def slice_data_dim0(df, v): # syntactic sugar to get R_{ALL} in a less verbose way df_temp = select_data(df, 0, v) return remove_first_dim(df_temp) In [3]: def buc_rec_optimized(df):# do not change the heading of the function pass # **replace** this line with your code In [4]: ## You can test your implementation using the following code… import helper import submission as submission input_data = read_data(‘./asset/a_.txt’) output = submission.buc_rec_optimized(input_data) output Out[4]: A B M 0 1 2 100 1 1 ALL 100 2 2 1 20 3 2 ALL 20 4 ALL 1 20 5 ALL 2 100 6 ALL ALL 120
