The highFIS model families

highFIS has thirteen families of TSK model. They share the same skeleton: Gaussian-like fuzzy sets, a rule for combining memberships into a firing strength, a normalization, and first-order consequents. They differ in the middle two steps, which is where high-dimensional data causes trouble.

Every family comes as a classifier and a regressor: HTSKClassifier and HTSKRegressor, DGTSKClassifier and DGTSKRegressor, and so on.

The map

Family	How it combines memberships and normalizes
`TSK`	product of memberships, normalized by their sum: the classic model
`HTSK`	geometric mean, normalized in log space
`LogTSK`	inverse-log normalization in the log domain
`DombiTSK`	Dombi T-norm with a learnable shape parameter
`AYATSK`	Yager T-norm
`ADATSK`	adaptive softmin-style inference with dynamic rule weighting
`ADPTSK`	adaptive softmin with two parameters and stable normalized weights
`ADMTSK`	adaptive Dombi, with composite Gaussian Pi membership functions
`MHTSK`	several heads, each on a subset of the features, with sparse consequents
`HDFIS`	high-dimensional inference with a product or a minimum T-norm
`DGTSK`	double-gated training: gates select features and extract rules
`DGALETSK`	adaptive Ln-Exp softmin with feature and rule gates built in
`FSRE-ADATSK`	`ADATSK` with gated feature selection and rule extraction

Three groups

Fix the arithmetic. HTSK and LogTSK keep the classic model and change how firing strengths are normalized, so the weights no longer collapse onto a single rule. If you have many features and no other requirement, start with HTSK.

Change the "and". The product is one way to say that all conditions of a rule hold. DombiTSK, AYATSK, ADATSK, ADPTSK, ADMTSK and HDFIS use other T-norms or soft minimums, several of them with parameters that are learned. They give the model more room to decide how strict a rule is.

Select while training. With thousands of features, most are noise. DGTSK, DGALETSK, FSRE-ADATSK and MHTSK learn which features each rule looks at, and which rules are worth keeping. What comes out is smaller and easier to read, which is the reason to use a fuzzy system at all.

Tip

Since every estimator follows the scikit-learn interface, comparing families is a loop over classes with cross_val_score. Start simple and move to a gated model only if you need the feature selection.

The pieces underneath

The families are assembled from parts that are public and can be combined in other ways:

Membership functions: highfis.memberships
T-norms: highfis.t_norms
Defuzzifiers: highfis.defuzzifiers
PyTorch models: highfis.models, for when you want to write the training loop yourself

Each family has a page in the documentation with its formulation, the paper it comes from and how the code maps to it.