def evaluate(self, array_data, user_conv): try: if isinstance(array_data.data[0], str): date_time = pd.to_datetime(array_data.data, infer_datetime_format=True) array_data.data = date_time else: date_time = array_data.data if not isinstance(array_data.data[0], pd.datetime): raise RuntimeError() except: Printer.Print("Cannot transform data to date time") return ResultObject(None, None, None, CommandStatus.Error) results = [] for word in ['day', 'year', 'month', 'hour', 'minute']: if word in user_conv.data or word + 's' in user_conv.data: out = getattr(date_time, word) result = ResultObject(out, [], DataType.array) result.createName(array_data.keyword_list, command_name=word, set_keyword_list=True) results.append(result) Printer.Print('Saving ', word, 'from ', array_data.name, ' as', result.name) if results != []: return results return ResultObject(None, None, None, CommandStatus.Success)
def evaluate(self, history, user_conv, name=None): """ Saves the last element from history and saves it with given name """ result_object = ResultObject(None, None, None, CommandStatus.Error) if 'notebook' in user_conv.data or 'chat' in user_conv.data: Printer.save(name) return ResultObject(None, None, None, CommandStatus.Success) elif 'table' in user_conv.data: result = save_table(name, user_conv) if not result: return result_object return ResultObject(None, None, None, CommandStatus.Success) if name is None: return result_object try: previous_result = history.data.getLastObject() name_lower = name.data.lower() keyword_list = name_lower.split(' ') result_object = ResultObject(previous_result.data, keyword_list, history.data.last_data_type, CommandStatus.Success) result_object.createName(keyword_list) Printer.Print("Saving ", ' '.join(previous_result.keyword_list), ' as ', result_object.name) except RuntimeError: Printer.Print("Cannot find last object from history") return result_object
def evaluate(self, array_datas): if not isinstance(array_datas, collections.Iterable): array_datas = [array_datas] N = array_datas[0].data.size out = np.full(N, 'Unknown', dtype='U40') out_filter = np.full(N, False) Printer.Print("Creating a categorical array from: ") for array_data in array_datas: Printer.Print(array_data.name) if array_data.data.size == N: out[array_data.data] = array_data.name out_filter[array_data.data] = True kl1 = [" ".join(array_data.keyword_list) for array_data in array_datas] truncated_kl1, common_name = StatContainer.removeCommonNames(kl1) if common_name == '': common_name_list = array_data[0].keyword_list else: common_name_list = common_name.split(' ') result = ResultObject(out, [], DataType.array, CommandStatus.Success) result.createName(common_name_list, command_name='categorical', set_keyword_list=True) result_filter = ResultObject(out_filter, [], DataType.logical_array, CommandStatus.Success, True) result_filter.createName(common_name_list, command_name='filter', set_keyword_list=True) Printer.Print('Saving categorical array as', result.name) Printer.Print('Saving filter as', result_filter.name) return [result, result_filter]
def evaluate(self, array_data): N = len(array_data) if N < 1: return ResultObject(None, None, None, CommandStatus.Error) out = array_data[0].data Printer.Print("Performing logical", self._add_tags[0], "on ") Printer.Print(array_data[0].name) if self._operator == '!': out = np.logical_not(array_data[0].data) for arr_data in array_data[1:]: Printer.Print(", ", arr_data.name) if self._operator == '&': out = np.logical_and(out, arr_data.data) elif self._operator == '||': out = np.logical_or(out, arr_data.data) elif self._operator == '^': out = np.logical_xor(out, arr_data.data) else: return ResultObject(None, None, None, CommandStatus.Error) Printer.Print(arr_data.name) if StatContainer.conditional_array is not None: non_filt_idx = np.logical_not(StatContainer.conditional_array) out[non_filt_idx] = False result = ResultObject(out, [], DataType.logical_array, CommandStatus.Success, True) if len(array_data) > 1: keyword_list2 = array_data[1].keyword_list else: keyword_list2 = [] result.createName(array_data[0].keyword_list, keyword_list2, command_name=self._add_tags[0], set_keyword_list=True) return result
def evaluate(self, data_frame, array_datas, classifier_algo, pre_evaluate_results=None): """ Train a classifier on multiple arrays """ result_object = ResultObject(None, None, None, CommandStatus.Error) if type(pre_evaluate_results) is not list: Printer.Print("Pre evaluation results failed! Attach bug report!") return result_object win = Window.window() if data_frame is not None: result_object = VizContainer.createResult(win, data_frame, ['cval']) elif array_datas is not None: result_object = VizContainer.createResult(win, array_datas, ['cval']) else: Printer.Print("Provide one of data frame or array datas") return result_object cv_output, aux_output = pre_evaluate_results properties, model_data = aux_output.data result_object.data = [win, properties, model_data, self.processkFoldCV] self.printkValueMessage(cv_output.data[0]) self.updateWindow(win, cv_output.data[1], cv_output.data[2], model_data[1], properties["title"]) self.modify_figure.evaluate(result_object) return result_object
def evaluate(self, array_data): """ Calculate sum of all elements of the array and store it to history Parameters: """ result_object = ResultObject(None, None, None, CommandStatus.Error) array = array_data.data if numpy.issubdtype(array.dtype, numpy.number): idx = numpy.logical_not(numpy.isnan(array)) if StatContainer.conditional_array is not None and StatContainer.conditional_array.data.size == array.size: idx = numpy.logical_and(idx, StatContainer.conditional_array.data) mean_val = numpy.sum(array[idx]) result_object = ResultObject(mean_val, [], DataType.array, CommandStatus.Success) result_object.createName(array_data.keyword_list, command_name=self.commandTags()[0], set_keyword_list=True) Printer.Print("Sum of", array_data.name, "is", mean_val) else: Printer.Print("The array is not of numeric type so cannot", "take sum") return result_object
def DataMineArgFoundResponse(self, arg_name): if arg_name == "data_frame": Printer.Print("Found the data frame") elif arg_name == "array_datas": Printer.Print("Found array data") else: Printer.Print("Found the classification models to test")
def evaluate(self, array_datas): """ Visualize the relationship between variables """ result_object = ResultObject(None, None, None, CommandStatus.Error) sns.set(color_codes=True) df = pd.DataFrame() for array_data in array_datas: if (np.issubdtype(array_data.data.dtype, np.number)) == True: Printer.Print("The data to plot is not categorical, Please use scatter plot") return result_object df[" ".join(array_data.keyword_list)] = array_data.data df.dropna(inplace=True) df = df.pivot_table( index=df.columns[0], columns=df.columns[1], aggfunc=np.size, fill_value=0) Printer.Print("Displaying heatmap") win = Window.window() f = win.gcf() ax = f.add_subplot(111) sns.heatmap(df, ax=ax) win.show() return VizContainer.createResult(win, array_datas, ['heatmap'])
def evaluate(self, image): """ Display the image specified """ try: if image.data_type is DataType.file_name: file_path = image.data.path if not os.path.isfile(file_path): Printer.Print("Cannot find image file: ", file_path) raise RuntimeError curr_image = imread(file_path) result_object = ResultObject( curr_image, image.keyword_list, DataType.image, CommandStatus.Success) else: curr_image = image.data result_object = ResultObject( None, None, None, CommandStatus.Success) image_name = image.keyword_list[0] win = Window.window() plt.imshow(curr_image) plt.gca().axis('off') win.show() Printer.Print("Displaying image" + image_name) except: result_object = ResultObject(None, None, None, CommandStatus.Error) return result_object
def read(self, file_path, keyword_list): try: property_data, model_name = self.createProperties(file_path) model = DataGuru.createModel(property_data, model_name) except: Printer.Print("File not found") return ResultObject(None, None, None, CommandStatus.Error) command_status = CommandStatus.Success result_data = [model, property_data, model_name, self.updateModel] result_object = ResultObject(result_data, keyword_list, DataType.algorithm_arg, command_status, add_to_cache=True) result_object.createName(keyword_list) if (PropertyEditor.parent_widget is None or PropertyEditor.property_editor_class is None): Printer.Print("Cannot modify algorithm properties in non-GUI mode") else: property_editor = PropertyEditor.property_editor_class( result_object) PropertyEditor.addPropertyEditor(property_editor) return result_object
def save_table_as_csv(table, path): if path is None: path = QFileDialog.getSaveFileName(None, 'Save File', '', 'CSV(*.csv)') try: path = path[0] except: return else: path = path.data Printer.Print("Saving table as csv: ", path) try: with open(path, 'w') as stream: writer = csv.writer(stream) header_data = [] for column in range(table.columnCount()): item = table.horizontalHeaderItem(column) if item is not None: header_data.append(str(item.text())) else: header_data.append('') writer.writerow(header_data) for row in range(table.rowCount()): rowdata = [] for column in range(table.columnCount()): item = table.item(row, column) if item is not None: rowdata.append( str(item.text())) else: rowdata.append('') writer.writerow(rowdata) except FileNotFoundError: Printer.Print("Cannot save to file: ", path)
def evaluate(self, alpha_script, parent_parser): """ Run an alfarvis script """ result_object = ResultObject(None, None, None, CommandStatus.Error) if alpha_script.data.data_type is not DataType.alpha_script: Printer.Print("File not of alpha script type: ", alpha_script.data.data_type) return result_object # Get the lines try: lines = [ line.rstrip('\n') for line in open(alpha_script.data.path) ] except: Printer.Print("Alpha script not found") return ResultObject(None, None, None, CommandStatus.Error) # Update parent parser state parent_parser.data.clearCommandSearchResults() for i, line in enumerate(lines): line = line.lstrip() print("Line: ", line) if len(line) == 0: continue elif line[0] == '#': continue # Ignore comments parent_parser.data.parse(line) if parent_parser.data.currentState == ParserStates.command_known_data_unknown: Printer.Print("Ambiguous command at line: ", i) Printer.Print("Exiting script") break parent_parser.data.clearCommandSearchResults() result_object = ResultObject(None, None, None, CommandStatus.Success) return result_object
def evaluate(self, array_data): """ Calculate count (number of values) of an array and store it to history Parameters: """ result_object = ResultObject(None, None, None, CommandStatus.Error) array = array_data.data if StatContainer.conditional_array is not None: array = array[StatContainer.conditional_array.data] nan_idx = StatContainer.getNanIdx(array) if numpy.issubdtype(array.dtype, numpy.number): array_filtered = array[numpy.logical_not(nan_idx)] count_val = numpy.count_nonzero(array_filtered) result_object = ResultObject(count_val, [], DataType.array, CommandStatus.Success) result_object.createName( array_data.keyword_list, command_name=self.commandTags()[0], set_keyword_list=True) Printer.Print("Count of", array_data.name, "is", count_val) else: Printer.Print("The array is not of numeric type so cannot", "find count") return result_object
def evaluate(self, data_frame, classifier_algo): """ Train a classifier on multiple arrays """ result_object = ResultObject(None, None, None, CommandStatus.Error) # Get the data frame df = data_frame.data #command_status, df, kl1, _ = DataGuru.transformArray_to_dataFrame(array_datas) if StatContainer.ground_truth is None: Printer.Print("Please set a feature vector to ground truth by", "typing set ground truth before using this command") result_object = ResultObject(None, None, None, CommandStatus.Error) return result_object else: df = DataGuru.removeGT(df, StatContainer.ground_truth) Y = StatContainer.filterGroundTruth() # Remove nans: df, Y = DataGuru.removenan(df, Y) # Get the classifier model model = classifier_algo.data[0] # Code to run the classifier X = df.values # Get a standard scaler for the extracted data X scaler = preprocessing.StandardScaler().fit(X) X = scaler.transform(X) # Train the classifier Printer.Print("Training the classifier") df_show = pd.DataFrame() df_show['Features'] = df.columns TablePrinter.printDataFrame(df_show) model.fit(X, Y) # Print an update Printer.Print("The classifier", classifier_algo.name, "has been trained") predictions = model.predict(X) accuracy = metrics.accuracy_score(predictions, Y) Printer.Print("Accuracy on training set : %s" % "{0:.3%}".format(accuracy)) trained_model = {'Scaler': scaler, 'Model': model} result_object = ResultObject(trained_model, [], DataType.trained_model, CommandStatus.Success) classifier_algo_name = classifier_algo.name.replace('.', ' ') result_object.createName(data_frame.keyword_list, command_name=classifier_algo_name, set_keyword_list=True) return result_object
def DataMineMultipleArgsFoundResponse(self, arg_name): if arg_name == "data_frame": Printer.Print("I found multiple data frames that seem to match your query") Printer.Print("Could you please look at the following data frames and tell me which one you " "want to classify?") elif arg_name == "classifier_algo": Printer.Print("I found multiple classification algorithms matching your query") Printer.Print("Could you please look at available classification algorithms: ")
def printArguments(self, args): if type(args) is DataObject: args = [args] if args is None: Printer.Print(" None") return for arg in args: Printer.Print(" ".join(arg.keyword_list))
def FindBestClassifier(self, modelList, num_folds, topFeatures=0): cdsvores = [] for i in range(len(modelList)): cdsvores1, aucscores = (self.classification_model(modelList[i]['Model'], num_folds, topFeatures)) cdsvores.append(cdsvores1) Printer.Print("Best classifier is " + modelList[np.argmax(cdsvores)]['Name'] + " with an accuracy of - %.2f%% " % max(cdsvores)) Printer.Print('--------------------------\n--------------------------\n')
def evaluate(self, data_frame, classifier_model): """ Run a trained classifier on multiple arrays """ result_object = ResultObject(None, None, None, CommandStatus.Error) # Get the data frame sns.set(color_codes=True) #command_status, df, kl1, _ = DataGuru.transformArray_to_dataFrame(array_datas) df = data_frame.data # if command_status == CommandStatus.Error: # return ResultObject(None, None, None, CommandStatus.Error) if StatContainer.ground_truth is None: Printer.Print("Please set a feature vector to ground truth by", "typing set ground truth to", "to get the prediction accuracy") result_object = ResultObject(None, None, None, CommandStatus.Error) return result_object else: df = DataGuru.removeGT(df, StatContainer.ground_truth) Y = StatContainer.ground_truth.data # Remove nans: df, Y = DataGuru.removenan(df, Y) X = df.values # Get the classifier model trained_model = classifier_model.data model = trained_model['Model'] scaler = trained_model['Scaler'] # Scale the values based on the training standardizer X = scaler.transform(X) # Code to run the classifier # Plot the classification result win = Window.window() f = win.gcf() ax = f.add_subplot(111) Printer.Print('Running the trained classifier...') predictions = model.predict(X) accuracy = metrics.accuracy_score(predictions, Y) Printer.Print("Accuracy : %s" % "{0:.3%}".format(accuracy)) cm = metrics.confusion_matrix(Y, predictions) DataGuru.plot_confusion_matrix(cm, np.unique(Y), ax, title="confusion matrix") win.show() # TODO Need to save the result result_object = ResultObject(None, None, None, CommandStatus.Success) return result_object
def read(self, file_path, keyword_list, pre_evaluate_results): if type(pre_evaluate_results) != list: Printer.Print("No preevaluation done!", " Please file a bug report with the chat") return ResultObject(None, None, None, CommandStatus.Error) # List the information about csv Printer.Print("Loaded " + " ".join(keyword_list)) self.list_command.evaluate(pre_evaluate_results[0], DataObject([''], [])) return pre_evaluate_results
def consumePreEvaluateResults(self, command, arguments, pre_evaluate_results): if (type(pre_evaluate_results) is not list and pre_evaluate_results.command_status == CommandStatus.Error): Printer.Print("Failed to evaluate parallel thread: ") if (type(pre_evaluate_results.data) == str): Printer.Print(pre_evaluate_results.data) return arguments['pre_evaluate_results'] = pre_evaluate_results self.postEvaluateCommand(command, arguments)
def evaluate(self, array_data): """ Create a pie plot """ result_object = ResultObject(None, None, None, CommandStatus.Error) sns.set(color_codes=True) stTitle = " ".join(array_data.keyword_list) if StatContainer.conditional_array is not None and len( StatContainer.conditional_array.data) == array_data.data.size: inds = StatContainer.conditional_array.data Printer.Print("Nfiltered: ", np.sum(inds)) else: inds = np.full(array_data.data.size, True) col_data = pd.Series(array_data.data[inds], name='array') col_data.dropna(inplace=True) try: uniqVals, inv, counts = np.unique(col_data, return_inverse=True, return_counts=True) except: return ResultObject(None, None, None, CommandStatus.Error) if len(uniqVals) > self.max_unique: if isinstance(uniqVals[0], str): best_idx = np.argpartition(counts, -self.max_unique)[-self.max_unique:] idx = np.isin(inv, best_idx) col_data = col_data[idx] elif np.issubdtype(col_data.dtype, np.number): # Convert to categorical col_data = pd.cut(col_data, 10) uniqVals = True else: uniqVals = None if uniqVals is not None: counts = pd.Series(np.ones(col_data.size), name='count') concat_df = pd.concat([counts, col_data], axis=1) ds = concat_df.groupby(col_data.name).sum()['count'] else: Printer.Print("Too many unique values to plot on a pie chart\n") Printer.Print("Please select another chart type") return result_object win = Window.window() f = win.gcf() ax = f.add_subplot(111) ds.plot.pie(figsize=(8, 8), ax=ax) ax.set_title(stTitle) ax.set_xlabel('') ax.set_aspect('equal') win.show() return VizContainer.createResult(win, array_data, ['pie'])
def checkHeaders(self, headers): if headers.size != 4: Printer.Print("Headers in data base file does not match") return False expected_headers = [ 'file_name', 'file_type', 'keywords', 'description' ] for i, header in enumerate(expected_headers): if header != headers[i]: Printer.Print("Header at ", i, " does not match with ", header) return False return True
def read(self, file_path, keyword_list): """ Load the file name specified and store it in history Parameters: file_path file location which is expected to be of type csv keyword_list keywords used to describe the database """ result_object = ResultObject(None, None, None, CommandStatus.Error) skipped_files = 0 mod_file_path = self.findFilePath(file_path) if mod_file_path is not None: # try: data_frame = pd.read_csv(mod_file_path) self.checkHeaders(data_frame.columns.values) result_list = [] for idx, row in data_frame.iterrows(): try: file_type = DataType[row['file_type']] except KeyError: # Depending on verbosity Printer.Print("file type in line ", idx, " not understood in", row['file_name']) Printer.Print("Skipping file ...") skipped_files = skipped_files + 1 continue if file_type == DataType.folder: Printer.Print("Loading folder: ", row['file_name']) read_folder = ReadFolder() result = read_folder.read( row['file_name'], row['keywords'].split(), 'recursive' == row['description']) if result.command_status == CommandStatus.Success: result_list.append(result) else: Printer.Print("Failed to load folder: ", row['file_name']) continue row_file_path = self.findFilePath(row['file_name']) if row_file_path is None: Printer.Print("Cannot find file: ", row['file_name']) continue file_object = FileObject(row_file_path, file_type, row['description'], False) keywords = row['keywords'].split(' ') file_res = ResultObject(file_object, keywords, DataType.file_name) file_res.createName(keywords) result_list.append(file_res) result_object = result_list # except: # result_object = ResultObject(None, None, None, CommandStatus.Error) return result_object
def evaluate(self, csv_data): """ Transform a csv to its standardized counterpart """ result_object = ResultObject(None, None, None, CommandStatus.Error) data = csv_data.data.copy() # if numpy.issubdtype(data.dtype, numpy.number): for column in data.columns: col_data_drop = data[column].dropna() uniqVals = StatContainer.isCategorical(col_data_drop) if (uniqVals is None and len(col_data_drop) > 0 and isinstance(col_data_drop.iloc[0], str) == False): data[column] = ((data[column] - numpy.mean(col_data_drop)) / numpy.std(col_data_drop)) Printer.Print("Saving the scaled data...") result_object = ResultObject(data, [], DataType.csv, CommandStatus.Success) result_object.createName(csv_data.keyword_list, command_name=self.commandTags()[0], set_keyword_list=True) return result_object
def evaluate(self, array_data): """ Calculate stdev value of the array and store it to history Parameters: """ result_object = ResultObject(None, None, None, CommandStatus.Error) array = array_data.data if numpy.issubdtype(array.dtype, numpy.number): idx = numpy.logical_not(numpy.isnan(array)) if StatContainer.conditional_array is not None and StatContainer.conditional_array.data.size == array.size: idx = numpy.logical_and(idx, StatContainer.conditional_array.data) std_val = numpy.std(array[idx]) result_object = ResultObject( std_val, [], DataType.array, CommandStatus.Success) result_object.createName( array_data.keyword_list, command_name=self.commandTags()[0], set_keyword_list=True) df_new = pd.DataFrame() df_new['Feature'] = [array_data.name] df_new['Standard Deviation'] = [std_val] TablePrinter.printDataFrame(df_new) # Printer.Print("Standard deviation of", array_data.name, # "is", std_val) else: Printer.Print("The array is not of numeric type so cannot", "find stdev") return result_object
def evaluate(self, array_datas): """ Displaying a heatmap for data visualization """ result_object = ResultObject(None, None, None, CommandStatus.Error) sns.set(color_codes=True) command_status, df, kl1, _ = DataGuru.transformArray_to_dataFrame( array_datas, remove_nan=True) if command_status == CommandStatus.Error: return ResultObject(None, None, None, CommandStatus.Error) Printer.Print("Displaying heatmap") win = Window.window() f = win.gcf() if StatContainer.ground_truth is None: sns.clustermap(df, cbar=True, square=False, annot=False, cmap='jet', standard_scale=1) else: gt1 = pd.Series(StatContainer.ground_truth.data) lut = dict(zip(gt1.unique(), "rbg")) row_colors = gt1.map(lut) sns.clustermap(df, standard_scale=1, row_colors=row_colors, cmap="jet") win.show() return VizContainer.createResult(win, array_datas, ['heatmap'])
def extractArgFromUser(self, key_words, argument): """ Extract argument from user input if possible """ data_res = [] for tag in argument.tags: try: index = key_words.index(tag.name) except: continue if tag.position == Argument.TagPosition.After: search_scope = key_words[(index + 1):] elif tag.position == Argument.TagPosition.Before: # Reverse list to be consistent with search # order search_scope = key_words[:index][::-1] else: search_scope = key_words if argument.argument_type is DataType.number: res = findNumbers(search_scope, argument.number) if len(res) != 0: data_res = data_res + res break elif argument.argument_type is DataType.user_string: res = DataObject(' '.join(search_scope), search_scope) data_res.append(res) break else: Printer.Print("Can only extract numbers and strings from user" "currently") break return data_res
def evaluate(self, array_datas): """ Create a line plot """ sns.set(color_codes=True) command_status, df, kl1, cname = DataGuru.transformArray_to_dataFrame( array_datas, useCategorical=True, expand_single=True, remove_nan=True) if command_status == CommandStatus.Error: return ResultObject(None, None, None, CommandStatus.Error) elif (df.shape[0] == 0 or (df.shape[1] == 1 and np.issubdtype(array_datas[0].data.dtype, np.number) == False)): Printer.Print("No data left to plot after cleaning up!") return ResultObject(None, None, None, CommandStatus.Error) win = Window.window() f = win.gcf() ax = f.add_subplot(111) ax.set_title(cname) df.plot(ax=ax) win.show() return VizContainer.createResult(win, array_datas, ['line'])
def evaluate(self, array_datas): """ Create a scatter plot between multiple variables """ result_object = ResultObject(None, None, None, CommandStatus.Error) sns.set(color_codes=True) command_status, df, kl1, cname = DataGuru.transformArray_to_dataFrame( array_datas) if command_status == CommandStatus.Error: return result_object if len(df.columns) <= 1: Printer.Print("There needs to be atleast two variables to perform multiscatter plot!") return result_object win = Window.window() f = win.gcf() ax = f.add_subplot(111) if StatContainer.ground_truth is None or len(StatContainer.ground_truth.data) != df.shape[0]: df.dropna(inplace=True) pd.plotting.scatter_matrix(df, alpha=0.2, diagonal='kde', ax=ax) else: gt1 = pd.Series(StatContainer.filterGroundTruth()) df, gt1 = DataGuru.removenan(df, gt1) lut = dict(zip(gt1.unique(), np.linspace(0, 1, gt1.unique().size))) row_colors = gt1.map(lut) pd.plotting.scatter_matrix(df, alpha=0.2, diagonal='kde', c=row_colors, cmap="jet", ax=ax) f.suptitle(cname) win.show() return VizContainer.createResult(win, array_datas, ['multiscatter'])
def FindTopPredictors(self, algoType="RF"): X = self.X Y = self.Y # If the selected algo is RF, find the top features using RF featImpVals = self.SortTopFeatures_RF(X, Y) # If the selected algo is TTest #featImpVals = self.SortTopFeatures_TT(X,Y) # If the selected algo is LogReg # = self.SortTopFeatures_LR(X,Y) self.featimp = pd.Series(featImpVals, index=self.columnList).sort_values(ascending=False) Printer.Print("Here is a sorted list of top features found using the " + algoType + "algorithm") Printer.Print(self.featimp) Printer.Print('--------------------------\n--------------------------\n') self.X = self.data[self.featimp.index[0:]].values self.columnList = self.featimp.index