Parsed Categoric Encodings with Automunge
Authors: Nicholas Teague
Venue:  (2021)
Keywords: tabular
feature engineering

Abstract: The Automunge open source python library platform for tabular data pre-processing automates feature engineering data transformations of numerical encoding and missing data infill to received tidy data on bases fit to properties of columns in a designated train set for consistent and efficient application to subsequent data pipelines such as for inference, where transformations may be applied to distinct columns in “family tree” sets with generations and branches of derivations. Included in the library of transformations are methods to extract structure from bounded categorical string sets by way of automated string parsing, in which comparisons between entries in the set of unique values are parsed to identify character subset overlaps which may be encoded by appended columns of boolean overlap detection activations or by replacing string entries with identified overlap partitions. Further string parsing options, which may also be applied to unbounded categoric sets, include extraction of numeric substring partitions from entries or search functions to identify presence of specified substring partitions. The aggregation of these methods into “family tree” sets of transformations are demonstrated for use to automatically extract structure from categoric string compositions in relation to the set of entries in a column, such as may be applied to prepare categoric string set encodings for machine learning without human intervention.

Under review as a conference paper at ICLR 2021
PARSED CATEGORIC ENCODINGS WITH AUTOMUNGE
Anonymous authors
Paper under double-blind review
ABSTRACT
The Automunge open source python library platform for tabular data pre- processing automates feature engineering data transformations of numerical en- coding and missing data infill received tidy data on bases fit to properties of columns in a designated train set for consistent and efficient application to subse- quent data pipelines such as for inference, where transformations may be applied to distinct columns in "family tree" sets with generations and branches of deriva- tions. Included in the library of transformations are methods to extract struc- ture from bounded categorical string sets by way of automated string parsing, in which comparisons between entries in the set unique values are parsed to iden- tify character subset overlaps which may be encoded by appended columns of boolean overlap detection activations or by replacing string entries with identified overlap partitions. Further string parsing options, which may also be applied unbounded categoric sets, include extraction of numeric substring partitions from entries or search functions to identify presence of specified substring partitions. The aggregation of these methods into "family tree" sets of transformations are demonstrated for use to automatically extract structure from categoric string com- positions in relation to the set of entries in column, such as may be applied to prepare categoric string set encodings for machine learning without human inter- vention.
AUTOMUNGE
Automunge is an open source python library, available now for pip install, built on top of Pandas (McKinney, 2010), SciKit-Learn (Pedregosa et al., 2011), Scipy (Virtanen et al., 2020), and Numpy (van der Walt et al., 2011). It takes as input tabular data received in a tidy form (Wickham, 2014), meaning one column per feature and one row per observation, and returns numerically encoded sets with infill to missing points, thus providing a push-button means to feed raw tabular data directly to machine learning algorithms. The complexity of numerical encodings may be minimal, such as automated normalization of numerical sets and encoding of categorical, or may include more elaborate feature engineering transformations applied to distinct columns. Generally speaking, the transformations are performed based on a "fit" to properties of a column in a designated train set (e.g. based set's mean, standard deviation, categorical entries), and then that same basis is used to consistently and efficiently apply transformations to subsequent designated test sets, such as may be intended for use inference for additional training data preparation.
The library consists of two master functions, automunge(.) and postmunge(). The automunge(.) function receives a raw train set and if available also a consistently formatted test set, and returns collection of encoded sets intended for training, validation, and inference. The function also returns a populated python dictionary, which we call the postprocess diet, capturing all of the steps and parameters of transformations. This dictionary may then be passed along with subsequent test data to the postmunge() function for consistent processing on the train set basis, such as for instance may be applied sequentially to streams of data for inference. Because it makes use of train set properties evaluated during a corresponding automunge() call instead of directly evaluating properties of the test data, processing of subsequent test data in the postmunge(.) function is very efficient.
Included in the platform is a library of feature engineering methods, which in some cases may be aggregated into sets to be applied to distinct columns. For such sets of transformations, as may in- clude generations and branches of derivations, the order of implementation is designated by passing transformation categories entries to set of "family tree" primitives described further below.

---

Under review as a conference paper at ICLR 2021
2 CATEGORIC ENCODINGS
In tabular data applications, such as are the intended use for Automunge data preparations, a com- tactic for practitioners is treat categoric sets in coarse-grained representation for presenta- tion to a training operation. Such aggregations transform each unique categoric entry with distinct numeric encoding constructs, such one-hot encoding in which unique entries each represented with their own column for boolean activations, or ordinal encoding of single column integer repre- sentations. The Automunge library offers some further variations on categoric encodings [Fig. 1]. The default ordinal encoding 'ord3', activated when the number of unique entries exceeds some heuristic threshold, has encoding integers sorted by frequency of occurrence followed by alphabeti- cal, where frequency in general may be considered more useful to training operation. For sets with a number of unique entries below this threshold, the categoric defaults instead make use of '1010' binary encodings, meaning multi-column boolean activations in which representations of distinct categoric entries may be achieved with multiple simultaneous activations, which has benefits over one-hot encoding of reduced memory bandwidth. Special cases made for categoric sets with 2 unique entries, which are converted by "bnry' to single column boolean representation, and sets with 3 unique entries somewhat arbitrarily applied with 'text' one-hot encoding. Note that each transform has a default convention for infill to missing values which may be updated for configure distinct columns.
'text'
'1010'
(one-hot encoding)
(binary encoding)
column1
colomnt. 1234
columnt dirce colemnt aquare columnt Stangle
columnt. 1918.0
columnt 3012.1
columnt 5918.3
circle
cirde
0
0
cirde
0
0
square
square
briengle
1234
1
0
0
NaN
0
0
0
NaN
0
0
0
'ord3' (ordinal by frequency)
'ord' (ortinal))
'anry'
(boolean)
circle
cirde
yes
cirde
yea
squaro
2
yos
square
2
triangie
3
1234
NaN
Figure 1: Categoric encoding examples
The categoric encoding defaults in general are based on assumptions of training models in the de- cision paradigms (e.g. Random Forest, Gradient Boosting, etc.), particularly considering that a binary representation may sacrifice compatibility for an entity embedding of categorical variables [4] as may be applied the context of a neural network (for which we recommend seeded repre- sentation of 'ord3' for ordinal encoding by frequency). The defaults for automation are all config- urable, and alternate root categories of transformations may also be specified to distinct columns to overwrite the automation defaults.
The characterization of these encodings as a coarse graining is meant to elude to the full discarding of the structure of the received representations. When we convert a set of unique values ('circle", 'square', 'triangle') } to {1, 2, 3), we are hiding from the training operation any information that might be inferred from grammatical structure, such the recognition of the prefix "tri" meaning three. Consider the word "Automunge". You can probably infer from the common prefix "auto" that there might be some automation involved, if you data scientist you might recognize
2

---

Under review as a conference paper at ICLR 2021
the word "munge" as referring to data transformations. Naturally may then ask how we might incorporate practices from NLP into our tabular encodings, such as vectorized representations in a model like Word2Vec (Mikolov et al., 2013). While this is worthy line for further investigation, some caution is deserved that the validity of such representations is built on a few assumptions, most notably the consistency of vocabulary interpretations between any pre-trained model and the target tabular application. In NLP practice it is common to fine-tune (Howard & Ruder, 2018) a pre-trained model accommodate variation in target domain. In tabular applications obstacles to this type of approach may arise from the limited context surrounding the categoric entries which in practice is not uncommon find entries as single words, or sometimes character sets that aren't t even words such as e.g. serial numbers or addresses. We may thus be left without the surrounding corpus vocabulary necessary to fine tune a NLP model for some tabular target, and thus the only context available to extract domain properties may be the other entries shared in a categoric set or otherwise just the surrounding corresponding tabular features.
STRING PARSING
Automunge offers a novel means to extract some additional grammatical context from categoric entries prior to encoding by way of comparisons between entries in the unique values of a feature set. The operation is conducted by kind of string parsing, in which the set of unique entries in a column are parsed to identify character subset overlaps between entries. In its current form the im- plementation is probably not at an optimal computational efficiency, which we estimate complexity scaling on the order of (((L)))), where N is the number of unique entries and L is the average character length of those entries. Thus the intended use case is for categoric sets with a bounded range of unique entries. In general, the application of comparable transformations the postmunge(() function is materially more computationally efficient than the initial fitting of the transformations to the train set in the automunge(.) function, particularly in variations with added assumptions for test set composition in relation to the corresponding train data.
test data in
The implementation to identify character subset overlaps is performed by first inspecting the set of unique entries from the train set, determining the longest string length (-1), then for each entry comparing each subset of that length to every equivalent length subset of the other entries, where if composition overlaps are identified, the results are populated in a data structure matching identi- fied overlaps to their corresponding souree column unique entries, and after each overlap inspection cycle incrementing that inspection length by negative steps until configurable minimum length overlap detection threshold reached. To keep things manageable, in the base configuration over- laps are limited to single identification per unique entry, prioritized by longest length. Note also that transformation function parameters may be activated to exclude from overlap detections any subsets with space, punctuation, or other designated character sets such as to promote single word activations.
There are few options of these methods to choose from [Fig. 2]. In the first version 'splt' any identified substring overlap partitions are given unique columns for boolean activations. In sec- ond version 'sp12' the full entries with identified overlaps resulting in a reduced number of unique entries such as may be intended as a reduced information content supplement to the original set, which we speculate could be beneficial in the context of a curriculum learning regime (Bengio et al., 2009). A third version 'sp15' is similar to the second with distinction that those entries not replaced with identified overlap partitions are instead replaced with an infill plug value, such as to avoid too much redundancy between different configurations derived from the same set. The fourth shown version 'sp15" is comparable to 'splt' but with the allowance for multiple concurrent activations to each entry, demonstrating tradeoff between information re- tention and dimensionality of returned data. Each of these versions have corresponding variants with improved computational efficiency to test set processing with the postmunge(.) function based on incorporating the assumption that the set of unique entries in the test set will be the same or a subset of those found in the train set.
replaced with the overlap partitions,
Some further variations include 'sp1'' in which concurrent activation sets are collectively consol- idated with binary transform to reduce dimensionality. Another variation is available as 'sbst' which instead of comparing string character subsets of entries to string character subsets of other entries, only compares string character subsets of entries to complete character sets of other entries.
3

---

Under review as a conference paper at ICLR 2021
spif
spl5
[olring overlep identficaaiio)
(string overlap ordinel) fexcude non-overleps)
Bouh Peteree North Poternee
1234 North Petension St Orlando, FL. 52714
2045 South Anderson St Alamonte Springs.
1132715
9456 South Peterson St Molfand, FL, 32789
4067 North Peterson St Oriando, FL 32714
5670 Avenue St Orlando, FL 32/16
South Pelarson Maillend, 32789
Altmmonee Springs, FL
None
Orindo,
'sp15''
string overiap with allowed concurrent activations
setto North Poturien
Buch Putureedd
Altenertt
oAtross opth
adtmmss
1234 North Poterson St Orlando, FL 52714
2045 South Anderson BI Alammnts Springs.
FL 92715
3456 South Peterson St Marfand, FL 32/89
4587 North Petersion St Orlendo, FL 32714
Avanue Orlando,
South Peterson Maltand, 32789
Other Alsamonte Springs,
None
Orarddo,
eptt/ app22 splS 15 have compersble variants sp18 spt8 sp10 /sp1 with added aesumptions of lest set compoettin for efficiency.
Figure 2: String parsing for bounded sets
4 PARSING UNBOUNDED SETS
The transformations of the preceding section were somewhat constrained toward use against cate- goric sets with a bounded range of unique entries in the training data due to the complexity scaling on train set implementation. For cases where categoric sets may be presented with an unbounded range of unique entries, such as in cases for all unique entries or otherwise unbounded, Automunge offers few more string parsing transformations to extract grammatical structure prior to categoric encodings.
As first example, categoric entries may be passed to a search function 'srch' in which entries are string parsed to identify presence user-specified substring partitions, which are then presented to machine learning by way of recorded activations in returned boolean columns specific to each search term or alternatively with the set of activations collected into a single ordinal encoded column. Some variations the search functions include the allowance aggregate multiple search terms into common activations or variations for improved processing efficiency based on added assumptions of whether the target has narrow range of entries. Note that these methods are supported by the Automunge infrastructure allowing a user to pass transformatiin function specific parameters to those applied to distinct columns also reset transformation function parameter defaults in the context of an automunge()) call.
Another string parsing option suitable for application both bounded and unbounded categoric sets is intended for purposes of detecting numeric portions of categoric string entries, which are extracted and returned in dedicated numeric column. Some different numeric formats are sup- ported, including entries with commas via 'nmem", and using the family tree primitives the returned sets may in the same operation be normalized such as with a z-score or min-max scaling. As with other string-parsigg methods priority of extracts are given to identified partitions with the longest character length. A comparable operation may instead be performed to extract string partitions from majority numeric entries, although suggest caution of applying these methods towards numeri- cal sets which include units of measurement for instance, as we recommend reserving engineering domain evaluations for oversight by human intelligence.
4

---

Under review as a conference paper at ICLR 2021
'Srot"
calegoric string search with pusted 'searct perumeter: [Martandd "Orando"' Witamontt Springsi
'srof ccmmaratle to erch. ordina))
(slring parse for number commas ok)
Imnz (rmom with 2 soore)
hmmef (rmom with mihymax)
adames poon.
adireas recc,
acDMas urch Mettord
addrea ecc.
addees
erdr
fertegs
eddemm wed
North Patamon Criando 30714
2040 South Anderson 21 Alterort Sprinss
52715
32715.000000
00.670041
149d Borth Peturson Madiand, FL seree
32/89 008000
1,6901611
1,000000
0
Nort Pelnston Orindoo 59714
32714,000000
30714.000000
-0.688700
0.000000
6/81 South Vetemon Madiand, FL Sp0ro
32789 000000
1,680161
1,000000
0
28716
52715 000000
-0.667041
0.013588
0
02735.714844
Orando,
50736. 714844
0,000000
0.289584
Figure 3: Numeric extraction and search for unbounded sets
FAMILY TREE AGGREGATIONS
An example composition string parsing transformation aggregations, including generations and branches of derivations by way of entries to the family tree primitives, are now demonstrated for the root transformation category 'or19' [Fig. 4], which is available for assignment to source columns in context of automunge(.) call. This transformation set is intended automatically extract grammatical context from tabular data categoric features with a bounded range of unique entries.
Root Category:
or20
column
UPCS
UPCS
NArw
1010 nmc7
spl9
1010 nmc7
sp19
nmbr
ard3
sp10
nmbr
ord3
sp19
0rd3
sp10
Returned
column UPCS 1010 (set)
columm UPCS_ 1010 (set)
columns:
column UPCS nmc7 nmbr
column nmc7
column WPCS_
_pp___rd_33 ___ddd
COAumn__PCS_.. __t_____________ _e1__ord3
Soolumn_PCSSCC UPCS_PCCU_SSC ww_____PC_____ppp_ee__ wttp__ppl________o ord3
Soclumn_UCC____ UPCS_scle _er____________oooo______
column UPCS spll_ $r$$_______________________
NArw
Figure 4: Example family tree aggregations for bounded categoric sets
The sequence of four character keys represent transformation functions based on the transformation categories applied to column. Note that each key represents set of functions which may include one for application to train/test set(s) in an automunge(.) call for initial fitting of transformations to properties of train set or a corresponding function for processing of comparably formatted test set in postmunge() on the basis of properties from the train set. The steps of transformations for each returned column are logged by way of transformation function specific suffix appenders the original column headers. Note also that some of the intermediate steps of transformations may not be retained in the returned set based on presence downstream replacement primitive entries to family tree primitives described further below.
The upstream application of an 'UPCS' transform serves the purpose converting categoric entry strings to all uppercase characters, thus consolidating entries with different case configurations, e.g. a received set with unique entry strings 'usa", 'Usa", ; 'USA' would all be considered an equivalent entry (there may be some domains where this convention is not preferred in which case user may
5

---

Under review as a conference paper at ICLR 2021
deactivate a parameter to exclude this step). Adjacent the 'UPCS' transform is 'NArw" which returns boolean activations for those rows corresponding to infill based on the root category "pro- cessdict" defined type of source column values that will be target for infill (processdict is data structure discussed further helow, whose entries may either be default or user specified). The included '1010' transform for binary encoding distinguishes all distinct entries prior to any string parsing aggregations to ensure full information retention after the 'UPCS' transform both for pur- poses of ML training and also to support any later inversion operation to recover the original format of data pre-trate te--rransforms as is supported in the postmunge(.) function. An alternate configuration could replace '1010' with another categoric transform such as one-hot or ordinal encodings. The 'nmc7' transformation function is similar to 'nmem' discussed earlier, but only string parses those unique entries which were not found the train set for a more efficient application in the postmunge()) function. These numeric extractions are followed by 'nmbr' function for 7-score normalization. Note that in some cases a numerical extract, such as those derived here from zip codes passed addresses, may in fact be more suitable to categoric encoding instead of numeric normalization. Such alternate configurations may easily be defined with the family tree primitives.
The remaining branches downstream of the 'UPCS' start with 'sp19' function performing string parsing replacement operations comparable to the 'sp12' demonstrated above, but with the assump- tion that the set of unique entries in the test data will be the same or subset of the train set for efficiency considerations. The 'sp19" parses through unique entry strings to identify character subset overlaps and replaces entries with the longest identified overlap, which results in returned columns with a fewer number of unique entries by aggregating entries with shared overlaps into a com- mon representation, which may then be numerically encoded such as shown here with an 'ord3' transform. The 'or19' family tree also incorporates a second tier of string parsing with overlap re- placement by use of the 'sp10' transform (comparable 'sp15' with similar added assumptions for 'sp19"). 'sp10' differs from 'sp19' in that unique entries without overlap
efficiency considerations are replaced in aggregate with an infill plug value to avoid unnecessary redundancy between encod- ings, again resulting reduced number of unique entries which may then be numerically encoded such as with 'ord3'. Note that Fig. 4 also demonstrates an alternate root category configuration as 'or20' in which additional tier of 'sp19' is incorporated prior to the 'sp10".
'or19'
"family tree" of transformations
intended to extract grammatical context from bounded categoric sets of unknown composition
address UPCS
addiress UPC
addrese
aderess address addresa
uddresa UPCS address
1234 North Pesonson Orlando, $2714
0.888770
0
2345 South Andersson SI Alsamonte Springs, 32327
0.867041
0
D
3456 South Peterson S1 Mailland FL 52/89
1.690181
0
D
1
408/ North Peremson Orlando, FL 32/14
0.8887660
0
0
Orlando, 32714
0.888760
6709 South Peterson St Mailtan, Ft
32759
1.890181
0
5858 North Other St Altamonte Sprins, FL
32/15
-0.857041
0
1
0
1
0
0.000000
0
0.000000
Figure 5: Demonstration of 'or19' returned data
Fig. 5 demonstrates the numerical encodings as would be returned from the application of the 'or19' root category to a small example feature set of categoric strings. might be worth restating that due to the complexity scaling of the string parsing operation this type of operation is intended preferably for categoric sets with a bounded range of unique entries in the train set. The composition of returned sets are derived based properties of the source column received in a designated train set, and these same bases are applied to consistently prepare data for test sets, such as sets that may be intended for an inference operation. In other words, when preparing corresponding test data, the same type and order of columns are returned, with equivalent encodings for corresponding entries and equivalent activations for specific string subset overlap partitions that were found in the train set.

---

Under review as a conference paper at ICLR 2021
SPECIFICATION
The specification of transformation set compositions for these methods are conducted by way of transformation category entries to of family tree primitives, which distinguish for each trans- formation category the upstream transformation categories for when that category applied as a root category source column and also the downstream transformation categories for when that category is found as an entry in an upstream primitive with offspring. Downstream primitive en- tries are treated as upstream primitive entries for the successive generation, and primitives further distinguish source column retention and generation of offspring.
upstream downstream
downstream offspring
primitive
generation
column action
parents
upstreem
replace
yes
siblings
upstream
first
supplement
aunisuncias
first
coustine
upelreem
supplement
no
childrnn
downstream
oftspring
replace
perents
niccesnephows
downsstreem skilings
offspring
supplement
coworkers
auntsuncies
offspring
replece
no
friends
downstream
oftspring
supplement
cousins
Figure 6: Family tree primitives
Transformation category family sets may be passed formdict" data structure, which is complemented by second "processdict" data structure populated for each transformation category containing entries for the associated transformation functions and data properties. The transformdict with transformation category entries to family tree primitives and corresponding processdict transformation function entries associated with various columns returned from the 'or19' root category set are demonstrated here [Fig. 7J. Here the single processdict entry of the transformation function associated with a transformation category is an abstraction for the set of corresponding transformation functions to be directed at train and/or test set feature sets.
automunge() call by way of a "trans-
UPCS
MAN
1010
mmc
9p10
rmbr
ondo
8010
root category
'or19''
'1010'
'nmo8'
Yrnbrr
'sp13'
'oro3'
'sp10'
'NAw''
upstrum
parents
['or19']
"mmmo"
"nmbrr
['pp13')
['sp10')
siblings
1]
[]
I1
transformdiie
suntsuncies
[]
['1010'
"ord3'
['NAww
cousiie
['NAww']
[NAw
['NAww]]
NNArw
['NAww'
(NArw'
['NArw]
downsiream primthvos
children
I'mce8)
[1
[1
[]
nlecesnephews
['sp13']
I1
[]
['spt0')
[]
[]
coworkers
[1010']
U1
11
[]
['ord3']
11
[ord3 []
friends
[]
1]
[(bint)]
[]
propessdict
UPCS
mme7
rmbr
spi9
or63
sp10
Figure 7: 'or19' specifications
7

---

Under review as a conference paper at ICLR 2021
7 EXPERIMENTS
Some experiments were run to evaluate comparison between standard tabular categoric representa- tion techniques and parsed categoric encodings. The data from the IEEE-CIS Kaggle competition (Vesta, 2019) was selected based on known instances of feature sets containing serial number entries which were expected as good candidate for string parsing.
The experiments were supported by the Automunge library's 's feature importance evaluation methods, in which a model is trained on the full feature set to determine base accuracy on partitioned validation set, and metrics are calculated by shuffle permutation (Parr et al., 2018), where the target feature has it's entries shuffled between rows to measure damping effect on the resulting aceuracy, the delta of which may serve as a metric for feature importance. Automunge actually aggregates two metries for feature importance, the first metric specific to a source feature by shuffling all columns derived from the same feature, in which a higher metric represents more importance, and the second metric specific to each derived column by shuffling all but the target the columns derived form the same feature, in which lower metric represents more relative importance between columns derived from the same feature. The experiment findings discussed below are based on the first metric. Although other auto MI. options supported in the library, this experiment used the base configuration of Random Forest (Breiman, 2001) for the model.
For the experiment, the training data paired down the top features based feature im- portance in addition to two features selected as targets for the experiments, identified in the data by 'id_30' and 'id_31'. These two features contained entries corresponding to operating system serial numbers and browser serial numbers associated with origination of financial transactions. By inspection, there were many cases where serial numbers shared portions of grammatical structure, as for example the entries Mac OS X 10 11 6', 'Mac OS X 10 7 5'} or ('chrome 62.0", 'chrome 49.0"). Scenarios were run which both of these features were treated different types of encod- ings, including 'text' one-hot encoding, 'ord3' ordinal, '1010' binary [Fig 1], and two string parse scenarios, the first with 'or19" [Fig 4, 5, 7] and the second with an aggregation of: 'sp19' (string parse with concurrent activations consolidated by binary encoding) supplemented by 'nmcm' (nu- meric extraction) [Fig 3] and 'ord3' (ordinal encoding). The feature importance was then evaluated corresponding to each of these encoding scenarios [Table 1].
Table 1: Feature Importance Metric Results
Encoding
Category
Accuracy
'id_30*
'id_31'
one-hot
'text'
0.98029
0.00135
0.00490
ordinal
'ord3'
0,98040
0,00193
0,00581
binary
'1110'
0.98045
0.00245
0.00699
string parse
'or19'
0.98082
0.00295
0.00914
string parse
'sp19'
0.98081
0.00279
0.00924
The experiments illustrate some important points about the impact of categoric encodings even out- side of string parsing. Here we see that binary encoding materially outperforms one-hot encoding and ordinal encoding. We believe that one-hot encoding is best suited for labels or otherwise just used for interpretability purposes. We believe ordinal encoding best suited for very high cardi- nality when set has large number of entries. We believe binary is the best default for categoric encodings outside of vectorization, and thus serves as our categoric default under automation.
The string parsing was found to have a material benefit to both of our target features. It appears the 'or19' version of string parsing was more beneficial to the 'id_30 feature and the 'sp19" version to the 'id_31' feature.
Part of the challenge of benchmarking parsed categoric encodings the nature of the application, in that performance impact of string parsing is highly dependent on data set properties, and not neces- sarily generalizable to metric that would be relevant for comparison between different features or data sets. We believe this experiment has successfully demonstrated that string parsing has the po- tential to train better performing models in tabular applications based on improved model accuracy and feature importance in comparisons for these specific features.
8

---

Under review as a conference paper at ICLR 2021
8 DISCUSSION
To be clear, we believe the family tree primitives [Fig 6] represent a scientifically novel framework, serving fundamental reframing of command line specification for muultitraansfom sets may include generations and branches of derivations applied by recursion. They are built on assumptions of tidy data and that derivations are all downstream of a specific target feature set, and are well suited for the final data preprocessing steps applied prior to the application of machine learning in tabular applications. We consider these primitives universal language for univariate data transformation specification and an improvement on mainstream practice.
Although this paper is being submitted under the subject of NLP, it should be noted that the string parsing methods as demonstrated are kind of a compromise from vocabulary vectorization, intended for tabular applications in esoteric domains with limited context or surrounding language such as could be used to fine-tune pre-trained model, and thus not suitable for mainstream NL.P models like BERT. We have attempted in this work a comprehensive overview of various permutations of string parsing that may be applied for scenarios excluding vectorization. That is not to say that vectorization may not still be achievable for instance each of the returned categoric encodings of varying information content returned from 'or19' could be fed as input to entity embedding layer [4] when the returned sets are used to train a model.
Further, this paper is not just intended to propose theory and methods. Automunge is a downloadable software toolkit, and the methods demonstrated here are available now in the library for push-button operation. It really is just as simple as passing a dataframe and designating root category of 'or19' to a target column. We believe the automation of string parsing for categoric encodings is a novel invention that will prove very useful for machine learning researchers and practitioners alike.
The value of the library extends well beyond string parsing. For instance, Automunge is an au- tomated solution missing data infill. In addition to the infill defaults for each transformation, user can select for each column other infill options from the library. including "ML infill" in which column specific Random Forest models (Breiman, 2001) are trained from partitioned subsets of the training data to predict infill to train and test sets. For example, when MI. infill is applied to the 'or19' set, each of the returned subsets will have their own trained infill model.
An important point of value is not just the transformations themselves, but the means by which they are applied between train and test sets. In a traditional numerical set normalization operation for in- stance, it is not uncommon that each of these sets is evaluated individually for mean and standard deviation, which runs a risk of inconsistency of transformations between sets, or alternate meth- ods to measure prior to validation set extraction runs the risk of data leakage between training and validation operations. In a postmunge(.) test set application, all of the transformation parameters derived from corresponding columns in the train set passed to automunge(.) after partitioning validation sets, which in addition to solving these problems of inconsistency and data leakage, we speculate that at data center scale could have material benefit to computational overhead and asso- ciated carbon intensity of inference, perhaps also relevant to edge device battery constraints.
Another key point of value for this platform is simply put the reproducibility of data preprocessing. If a researcher wants to share their results for exact duplication to the same data or similar application to comparable data, all they have to do is publish the simple python dictionary returned from an automunge() call, and other researchers can then exactly duplicate. The same goes for archival of preprocessing experiments source data set need only be archived once, and every performed experiment remains accessible and reproducible with this simple python dictionary.
Beyond the core points of feature engineering and infill, the Automunge library contains several other push-button methods. The goal is to automate the full workflow for tabular data for the steps between receipt of tidy data and returned sets suitable for machine learning application. Some of the options include feature importance evaluation (by shuffle permutation (Breiman, 2001)), dimen- sionality reduction (including by means of PCA (Jolliffe & Cadima, 2016), feature importance, and binary encodings). preparation for oversampling in cases of label set class imbalance (Buda et al., 2017), evaluation of data distribution drift between initial train sets and subsequent test sets, and perhaps most importantly the simplest means for consistently and efficiently processing subsequent data with postmunge(.).
Oh, and once you try it out, please let us know.

---

Under review as a conference paper at ICLR 2021
ACKNOWLEDGMENTS
A thank you owed to: the Kaggle IEEE-CIS competition which helped me recognize the potential for string parsing. Mark Ryan who shared a comment in Deep Learning with Structured Data that was inspiration for the 'UPCS' transform. Thanks Stack Overflow, Python, PyPI, GitHub, Colab- oratory, Anaconda, and Jupyter. Special thanks to Scikit-Leam, Numpy, Scipy Stats, and Pandas.
REFERENCES
Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning, ICML '09, pp. 41-48, New York, NY, USA, 2009, Association for Computing Machinery. ISBN 9781605585161. doi: 10.1145/1553374.15553 1553380. 0113337.11553380
URL
Leo Breiman. Random forests. Machine Learning, 45(1):5-32, 2001. doi: 10.1023/A:
1010933404324. URL /ttp:///////////...///.//00/.000
Mateusz Buda, Atsuto Maki, and Maciej A. Mazurowski. A systematic study of the class imbalance problem in convolutional neural networks. arXiv e-prints, art. arXiv:1710.05381 October 2017.
Jeremy Howard and Sebastian Ruder. Universal Language Model Fine-tuning for Text Classifica- tion. arXiv e-prints, art. arXiv:1801.000 (6,14,,16 January 2018.
Ian Jolliffe and Jorge Cadima. Principal component analysis: review and recent developments. Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sci- ences, 374:20150202. 04 2016. doi: 10. (008//sta.2015.0200
Wes McKinney. Data structures for statistical computing in python. Proceedings of the 9th Python in Science Conference, pp. 51-56, 2010.
Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient Estimation of Word Repre- sentations Vector Space. arXiv e-prints, art, arXiv:1301.788) January 2013.
Karthika Mohan and Judea Pearl. Graphical Models for Processing Missing Data. arXiv e-prints, art. arXiv:1801 00358,, January 2018.
Terrence Parr, Kerem Turgutlu, Christopher Csiszar, and Jeremy Howard. Beware default ran- dom forest importances. Explained.ai (blog), 2018 URL rf rf-importance!
Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, Jake Vanderplas, Alexandre Passos, David Cournapeau, Matthieu Brucher, Matthicu Perrot, and Édouard Duch- esnay. Scikit-learn: Machine learning in python. Journal of Machine Learning Research, 12: 2825-2830, 2011.
Stefan van der Walt, Chris Colbert, and Gael Varoquaux. The numpy array: A structure for efficient numerical computation. Computing in Science & Engineering, 13:22-30, 2011.
Vesta. IEEE-CIS fraud detection data set. Retrieved Nov 12, 2020 from ht https: / wwww//wkkkkkk waggle. com/c/ieed fraud- detection/, 2019.
Pauli Virtanen, Ralf Gommers, Travis Oliphant, Matt Haberland, Tyler Reddy, David Courna- peau, Evgeni Burovski, Pearu Peterson, Warren Weckesser. Jonathan Bright, Stéfan van der Walt, Matthew Brett, Joshua Wilson, K. Jarrod Millman, Nikolay Mayorov, Andrew Nelson, Eric Jones, Robert Kern, Eric Larson, C. J. Carey, Ilhan Polat, Yu Feng, Eric Moore, Jake VanderPlas, Den- nis Laxalde, Josef Perktold, Robert Cimrman, Ian Henriksen, E. A. Quintero, Charles R. Har- ris, Anne M. Archibald, Antônio Ribeiro, Fabian Pedregosa, Paul van Mulbregt, and SciPy Contributors. SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python. Nature Methods, 17:261-272, 2020. doi: https://doi.org/10..
Hadley Wickham. Tidy data. Journal of Statistical Software, Articles, 59(10):1-23, 2014. ISSN 1548-7660. doi: 10. 10.18887/ss.v005..ll URL https: /www. .ow..tt/05.ooo....5..... 110.
10

---

Under review as a conference paper at ICLR 2021
APPENDIX
A
BROADER IMPACT
The following discussions are somewhat speculative in nature. At the time of this writing Auto- munge has yet to establish what we would consider a substantial user base and there may be bias towards optimism at play in how we have been proceeding, which we believe is our sole leverage of bias.
From an ethical standpoint, we helieve the potential benefits of our platform far outweigh any neg- ative aspects. What we noted in the discussions about the potential for reduced carbon intensity for machine learning at scale has been one of our guiding principles for design. Particularly we have sought to optimize the postmunge()) function for speed, used efficiency. As rule of thumb, processing times for equivalent data in the postmunge() function, such could be applied to streams of data in inference, have shown operate the order of twice the speed of initial preparations in the automunge()) function, although for some specific transforms like those implementing string parsing that advantage may be considerably higher. While the over- head may prevent achieving the speed of directly applying manually specified transformations to a dataframe, the postmunge(.) speed gets close manual transformations with increasing data size.
proxy for computational
We believe too that the impact to the machine learning community of formalized open source standard to tabular data preprocessing could have material benefits to ensuring reproducibility of results. There for some time has been gap between the wide range of open source frameworks for training neural networks in comparison to options for prerequisites of data pipelines. found some validation for this point from the tone of the audience Q&A at certain 2019 NeurlPS keynote presentation by the founder of commercial data wrangling package. fact may be considered potential negative impact of this research in the risk to commercial models of such vendors, as Automunge's GNU GPL 3.0 license coupled with patent pending status on the various inventions behind our library (including these string parsing methods, family tree primitives, ML infill, and etc.) will preclude commercial platforms offering comparable functionality. We expect that the benefits to the machine learning community in aggregate will far outweigh the potential commercial impacts to this narrow segment.
Further, benefits of automating machine learning derived infill missing data may result in ma- terial impact to the mainstream data science workflow. That old rule of thumb often thrown around about how 80% of machine learning project is cleaning the data may need to be revised to lower figure. We speculate that other options for generalized missing data infill, such as methods built around do-calculus (Mohan & Pearl, 2018), may have benefits for generality across multiple target labels in data lake (the ML infill method predicts infill on a basis of a specific target feature set), but there may be trade-offs for computational overhead of implementation, not to mention simplicity.
Regarding consequences of system failure, it should be noted that Automunge is an industry agnostic toolset, with intention to establish users across wide array of tabular data domains, potentially ranging from the trivial to mission critical. We recognize that with this exposure comes additional scrutiny and responsibility. Our development has been performed by a professional engineer and we have sought to approach validations, which has been ongoing process, with a commensurate degree of rigor.
Our development has followed incremental and one might say evolutionary approach to systems engineering, with frequent and sequential updates as we iteratively added functionality and trans- forms to the library within defined boundaries of the data science workflow. The intent has always been to transition to a more measured pace at such time as we may establish a more substantial user base.
11

---

Under review as a conference paper at ICLR 2021
B FUNCTION CALL DEMONSTRATIONS
Automunge is available for pip install:
pip install Aut
Or to upgrade (we currently roll out upgrades fairly frequently):
pip install Autnne
upgrade
Once installed, run this local session to initialize:
from Auune import Aut omunger am = Attomunnger.Auttaunnne ()
Then, assuming we want prepare train set df train for MI., can apply default parameters as:
train, trainID, labels, validationl, validationIDI, valicationlabelst, \ validation2, validationID2, validationlabelel,
test, testID, testlabels, labelseencodin__dictt fimalcolumms_trainn mamalcolumns_eene featureimportance, am. outnge (df_train)
sepprooess_dictt =
Note that if our df_ train set included labels column, should designate the column header with the lobuln parameter. Or likewise we can designate any ID columns with the wainnD.colume parameter.
The returned postprocess.dict should saved such as with pickle.
We can then consistently prepare subsequent test data dfttet in postmunge()):
test, testID, testlabels,
label sencodi ct, postreports_ \ am. postmunge catpssstroosss__ddct df_test)
find it helps to just copy and paste the full range of parameters for reference:
train, trainID, labels, validationi, validationIDI, salidationlabelss \ validation2, validation102, validationlabed test, testTD, testlabels, labelsencodingg_iie finalcolumss_tran
finalcolums_test,
featureimportancee, postprocess_dictt -
am aut.omuung (df_ df_test=False, labeis_colum==Falle
traintD_columm=tan test:D_coolmm=Fallse. valpercent1=.0,
flocaprrecissoo==222,, ptt.epeccecaaooeaeeeeeeaeeeeeeor sheffeettttteeerriiiereeeee, TrabhlabbelFreggdaealFFsss,,,, binstraansform=FFllss,,, Mlinfill=False, infilliterate=l,,
valpercent2=.00,
htg.://eeee..a.aaaooooooorrrraar povertrannsoomFFFleee
Sag.tooesSS.aciinnnttainnaaaaaa. randomseea=42,, svala
Label_Shootthannn_tttttsaaasssss Laceeeoeeeeeeaoootooooooaaaaaaer LSfit=False,
nunbercateeporyheerrissccc.,,,
MArw_marker==Fallee, feeturesallettioossaalleee, featurepct=1.0, ,
featuremeetrio=0.00 featuremeetoodi-aeeffall... Binary-False,
pCan_componentt=FFllee, PCAexc1=[), excl_suffix-False,
ML_emnd = ('MLinfili_typel 'default', :
'MLinfill_cmnd" (tt.aaadddaaaanoooooroooeeeeeee ('RandomForeessseeee ['Mandomforrttlllssiiiie""
'PCA_type': 'defaul'', 'PCA_cmnd's )
12

---

Under review as a conference paper at ICLR 2021
assigncat
'mmbr' : 'retn': [], mmnmx [])
'mean' [],
:MAD3': [I,
'1gnm' [],
'bins' 'bsor': 'pwrs': 'pwr2' [], 'por2 [],
'bxcx' :]],
'addd': 'sbtr': 'mltp': IIl 'divd's :[],
'log0':[1 'logl': [],
'logn': [lln 'sqrt': []], "rais" : II,,
'absl [],
'bnwd': :
'bnwk': :[],
"bnwM':ll 'bnwo' ;[],, "bnKo':
'bnMo' [],
'bnep' :[],
'bne7': []
'bne9': :[]]] 'bneo': [[] "bn7o's [],
'bn9o's :[],
'bkt1' :[],
'bkt2': [],
'bkt3": "bkt4':
'nbr2 :[],
'nbr3'; []
'MADn": 'MAD2':
'tlbn'; [],
'mnm2' [[],
'mnm3': []
'mnm4':
'mnm5': []],
"mnm6'; [],
'ntgr' [[],
'ntg2': []
'ntg3': 'mea2': :[] "mea3': ;:[]. 'bxc2
'dxdt." [[],
'd2dt' :[],
'd3dt' :: 'xx22' [[],
'2222' :[],, 'd3d2'
'nmdx' [],,
'nmd2' [],
'nmd3': 'shf4' :[] *shf7's " [],
'mmdx' : :[],
'mmd2' ; "[,, 'mmd3':l]
'shft :[],
'shf2' [] 'shf3':
'shf8':ll,
'bnry' [[],
onhht : []
'text': []] 'txt2' [[],
*1010" [[],,
'or10'11
'ordl'' : []
'rdd2 []
'ord3": ordd4' :[]
*om10' [],
'mmor's [[]]
'Unht :: :]
'Utxt's : [],
'Utx2': 'Uor3': [],, 'Uo66': :[]
'U101'11
'splt': 'sp19' [],
'sp12': []
'sp15': 'sp15':
'sp19' [] 'abst':
'sp18' []],
'sp10': 'sp16': 'sp20' [], "sbs2':
'srch' []]
'src2': []
'srce': 'strn' : [], 'ingt" [], 'aggt':
'mmre' [[],
'nmr2': [],
'nmem'
'nmc2' [] 'nmEU': : :[], 'nmE2':
1mm77' : :[],
'nmr8': []
'nmc7':
1mmc"" :[] nmE7 ':[], 'nmE8':
orr22' []],
'ors5' [],
'ors6': ors7': []] "ucct" : :[[], "Uct'
'or15': [[],
'or17': []
'or19': or20': 'o221' : []]
'rr22:
"late':10 'dat2': :[),
'dat6': 'wkdy': [[] 'bshr' []],
hllyy :ll,
wwkds':0. 'wkdo': [] 'mnts':ll 'mato':
"yea2': 'mnt2': 'mnt6': []] 'day5': [],
'hrs2' :[],
'hrs4': "min2"[[] 'min4': "sen2':1: 'DPrt : [],
'DPnb':[]. 'DPmm' : ::],, 'DPbn':l] 'DPod':[], 'DP10': IDPoh':l]
Texcl':[] 'exc2': [I), 'exc3':ll, ex) 'exc5': 'exc6': :ll,
[n] coop''ll.. 'shfl':ll, 'eval':l), 'ptfm' [1),
assignparam
['défault__ssiimaaramm
(category) ('(parameter) 42)),
(category) { ('(column) {' ('(aarameter) : 42))),
assigminfill
('stdrdinfill'''l) 'Miinfill':
zeroinfill':l) 'omeinfill':(1,
'djiif:ll'::l), 'meaninfill':(1: 'medianinfill::0
modeinfill'::l) 'Lcinfill':l1, 'naninfill':
assignnan ('categories': 'columns':1), (
transformdict=(), processdict=(), evalcat=False, privacy_encode False, printstatus==rre)
Or for postmunge()) with full range of parameters:
test, testID, testlabels,
labelsencodingg _ictt postreports_ dict am. iontmusu (postprocess_dice df df_test, test.D_collum False, labelscolumn False, pandasoutput False, printstatus True, Freiiee = False, featureeval False, driftreport False, Label LabelSmoothing False, LSfit = False, inversion = False, traindata False, returnedsets True, shuffletrain = False)
13

---

Under review as a conference paper at ICLR 2021
C ASSIGNING TRANSFORMS AND INFILL
Assigning root categories is conducted in assigncat parameter, assigning infill in assigninfill, and parameters in assignparam - e.g. for train set df_train with column headers 'coll' and 'col2' could assign string parsing (splt) and a string parse family tree (or19) with infill types zero infill and ML infill.
Since 'splt" transform accepts parameters, we'll also demonstrate passing parameter of excluding space and special characters, such as promote single word overlap detections.
Note any columns we don't explicitly assign will defer to automation or we could turn off auto- mated defaults for pass-through other columns by passing automunge parameter powertransform 'excl'.
train, trainID, labels, \ validationl, validationIDl, valicationlabelsl, validation2, validationID2, valicationlabelsk, test, testID, testlabels, labelsencoding_dice finalcolumns t_tair,,nn finalcolumns_test,
featureimportance, postprocess_ diet am, aum.automunge (df_train assigncat ''spl''l''ool'
assigninfill ('zeroinfill': (cooll',, 'MLinfill's ('col')))
assignparam ('splt' ( ('coll's :
sepace__nd_punctuuae
Falss))))
14

---

Under review as a conference paper at ICLR 2021
D OVERWRITING SETS OF TRANSFORMS
Here we'll demonstrate overwriting sets of transformations with the transformdict parameter passed automunge(.).
Let's use the example from paper of "or19' application of "nmr7" to extract numerical portions which has result of returning the zip codes in the address examples. We noted in paper that there might be benefit to encoding the output as categorical instead of numeric (z-score) normalization, so let's demonstrate overwriting the pre-defined transform apply a categoric encoding downstream of the 'nmr7'.
Referring to Figure 7, we see the relevant family tree is for category 'nme8' which has a children primitive entry of 'nmbr'. These family trees are also available for inspection in the READ ME.
So if want instead encode the numeric extract as categorical, we could overwrite 'nmc8' in custom passed transformdict.
Note that since 'nmc8' is called as part of an offspring generation, the 'nme8' upstream primitives (parents / siblings / auntsuncles cousins) aren't inspected in context of 'or19", so we only have to worry about the downstream primitives (children niecesnephews coworkers friends).
Let's demonstrate the overwrite, we'll 'll instead use 'ord3' for ordinal encoding by frequency.
t trans formdictt
'nmo8'
'parents'
''nmc81)
'iblings' [],
auntsuncles! [],
cousinn'' ['NArW"]
childrenn ['ord3'],
'riecesnephews' [],
'coworkers' [],
'friends' : [1)}
And since we are using existing categories from the library, we don't need to repopulate a corre- sponding processdict.
Then when call automunge()) we can pass this transformdict to overwrite 'nmc8':
train, trainID, labels, \ validationi, validationIDI, valicationlabelsl, validation2, validationID2, validationlabells. test, testID, testlabels, labelsencodiigg_dict, finalcolumns_trre trrinn, finalcolumms_test,
featureimportancee, postprocess_dice \
am. (df_train, assigncat ['or19'(('oo221]] transformdict transformdict)
The returned columns log the steps of transformations via suffix appenders, so this replaces the original returned column 'col2 UPCS nme7 nmbr' with 'col2 UPCS nmc7 ord3'.
15

---

Under review as a conference paper at ICLR 2021
E FEATURE IMPORTANCE
The Automunge library includes an option for push-button feature importance evaluation by shuffle permutation, in which model is trained on the full training set feature set with base accuracy evaluated on partitioned validation set. Metrics are then derived by shuffling the rows of target feature determine the resulting delta from dampened accuracy. In the first metric all of the columns derived from the same source feature are shuffled, and higher metric signals higher influence of source feature. the second metric, all columns except for target column originating from the same source feature are shuffled, and lower metric signals higher relative influence in comparison the other columns derived from the same source feature. The current basis for performance metrics accuracy for classification and mean squared log error for regression. Note that the method requires the inclusion and designation label column by the labels.colume column parameter.
Feature importance is supported by the following automunge()) parameters:
featureselection: boolean (default False), when True feature importance is performed
accepts entries ('default', 'pet', 'metric', 'report), where 'default' evalu- ates feature importance and then processes data in general automunge()) call, 'report' evaluates feature importance without further processing of data, and 'pet' or 'metric' ac- tivate dimensionality reduction on returned data based the results, further detailed in READ ME documentation.
featuremethod:
The results of an evaluation are returned in the printouts, and then also in the returned dictionary featurcimportance. Sorted results are further available in the returned postprocess dict dictionary under the key 'FS 'FS sported'
Note that feature importance also be conducted subsequent data in the postmunge(.) function by activating the boolean featureeval parameter, with results available in printouts and returned in the returned dictionary postreports dict.
The second metric for relative importance between columns derived from the same feature are par- ticularly useful for evaluating influence of different segments of feature set's distribution. For example, when a categoric feature is encoded by 'text' one-hot encoding the metrics may indicate which of the categoric entries are more influential to the model. Similarly, when numeric feature is encoded by 'tlbn' tail bins encoding, the metrics may indicate which segments of the numeric set's distribution are more influential the model.
Important to keep in mind that feature importance metrics are much a measure of the model as they are of the features.
16

---

Under review as a conference paper at ICLR 2021
F A FEW HELPFUL HINTS
A few highlights that might make things easier for first-timers:
1) automunge()) returns sets numpy arrays by default (for universal compatibility with ML plat- forms). A user can instead receive the returned sets as pandas dataframes by passing the parameter pandasoutput True
2) Even the sets are returned as numpy arrays, you can still inspect the returned column headers with the returned list we demonstrate as finalcolumns ttrin
3) Printouts are turned on by default, they can be turned off with printstatus=False
4) Note for data sets with just a few rows, such as those demonstrated here, there is PCA heuristic to apply dimensionality reduction when the number of features is more than 50% of the number of observations in the train set (this is a somewhat arbitrary heuristic). This can be turned off with ML cmnd = { PPCA type":'off")
5) Speaking of PCA, you do want to apply PCA, useful option allows you exclude from dimensionality reduction boolean or ordinal encoded columns, available with ML.cmnd ('PCA.cmnd': :bbool_orddd PCAexel':Truee
6) Note that data shuffling is on by default for the train set and off by default for the test sets returned from automunge()) and postmunge().. you want to shuffle the test data in automunge too you can pass shuffletrain 'traintest'. Or to shuffle the test data returned from postmunge you can pass the postmunge parameter shuffletrain True.
7) The automated feature importance evaluation is easy to use, you just need to be sure to designate a label column with labels column 'column header'. Then just pass featureselection = True and printouts will return results well as the returned report featureimportance
8) To ensure that you can later prepare additional data for inference, please be sure to save the returned postprocess_dict such as with pickle library.
9) Importantly, when you pass a train set to automunge(.) please designate any included labels column with labels coluumnc = (label column header string), which may be an integer index for numpy arrays. When you go to process additional data in postmunge, the columns must have consistent headers those originally passed to automunge. Or if you originally passed numpy arrays, just be sure that the columns are in the right order. If you're 'ree passing postmunge()) data that includes a column originally designated as a label to automunge, just apply labelscolumn True.
10) Speaking of numpy arrays, you pass numpy arrays instead of pandas dataframes to the func- tion, all of the column assignments will accept integers for the column number.
11) When applying ML infill, which is based on Scikit-Learn Random Forest implementations, useful ML_emnd if you don't mind little more training time is to increase the number of timators as e.g. ML_cmmn
-nniiiiillmddd'::.... "RandomForrstClaaiffee" of " FanddomForesRRerresooo :f 1ottimmttoss:100000
12) Note that any columns you want to exclude from processing, you can either assign them to root category 'excl' in assigncat if you don't mind their retention (noting that they will still be included in ML infill so will need numerical encoding), or you can carve them out from the set to be returned in ID sets consistently shuffled and partitioned such as between training and validation data, just pass a list of column headers to trainID column and/or testID column. You can also turn off the automated transforms and only perform those designated assigneat by passing powertransform=
G INTELLETTUAL PROPERTY DISCLAIMER
Automunge is released under GNU General Public License v3.0. Full license details available on GitHub. Contact available via (anonymized). Copyright (C) 2020 All Rights Reserved. Patent Pending, applications (anonymized)
17


Reviews:
[{"review_id": "gDK6rfa_pKj", "reviewer": "AnonReviewer2", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": 2, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "This package aims at automating some repetitive tasks that data analysts (especially within the NLP domain) deal with. I confirm that tasks like feature selection and string encoding are beneficial for applied researchers with textual data. I can see a wide interest in the community.\nOn the negative side, the paper lacks a literature review and comparison with any existing and relevant work. I expected to see performance plots for different tasks (whether just for this package or with comparison to some baseline alternatives.\n\nAs a minor comment, I don't think having \"String theory\" in the title is a good idea because this keyword is already taken to refer to another scientific topic ( a sub-field of physics).\n", "extra_scores": {}, "extra_text": {}}, {"review_id": "Ur4Yf3HEyx", "reviewer": "AnonReviewer1", "summary": "", "questions": "", "limitations": "", "rating": 4, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "This paper introduces a library that preprocesses tabular data called Automunge.\n\nFor software packages I feel that one of two criteria must be met: The software implements a scientifically novel algorithm, framework, model, etc.; or the software package is so complex that a well-designed implementation in itself is of scientific significance.\n\nWhereas Automunge seems like a useful library, I am not convinced that it falls in either of these two categories. As such, I am not sure it justifies a publication at a machine learning conference. I suggest the authors target a different venue (e.g., PyCon, SysML, etc.) or elaborate on the scientific impact of their software (e.g., show experimentally that this framework allows practitioners to train better performing models).\n\nPros\n\n* The library seems useful\n\nCons\n\n* No significant novelty\n* Little relevance to the scientific machine learning community\n* Not very clearly written", "extra_scores": {}, "extra_text": {}}, {"review_id": "C2cjMyyPqxd", "reviewer": "AnonReviewer4", "summary": "", "questions": "", "limitations": "", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "The submitted paper describes a very nice featurization library, AutoMunge, that converts NLP into features suitable for NNs.\n\nIt's clear that the authors of the library have put a lot of thought into its construction, and it looks very useful.\n\nHowever, ICLR is about /learning/ representations, not about feature engineering. So this is off-topic for the conference. To make it on-topic, the authors could, e.g., compare using standard word representation techniques vs AutoMunge on a set of NLP tasks using some popular modern NLP architecture (perhaps BERT?). That would be a really interesting paper.\n", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: 
This paper presents "Automunge" a python library for pre-processing tabular data. 
The authors develop a useful library that can be used by practicioners for data engineering in NNs applications. 
The reviewers raised a common concern regarding the lack of focus on the actual usefulness of the librabry in improving the 
performance of the models that is applied on. A common concern was the lack of performance plots compared to other alternatives. 
In the response the authors have done a rather thorough job of addressing the reviewers comments and
adding material in the supplementary. However, given the current presentation, the manuscript needs a considerable amount of  rewriting to incorporate the suggested changes into the main paper. As it is, I don't think ICLR is the right venue for the manuscript.  It might reach its audience better in venues like SysMl or PyCon also suggested by a reviewer. 

Decision: Reject