Metadata-Version: 2.5
Name: fylearn
Version: 0.2.3
Summary: Fuzzy Machine Learning Algorithms
Project-URL: Repository, https://github.com/sorend/fylearn.git
Project-URL: Issues, https://github.com/sorend/fylearn/issues
Maintainer-email: Søren Atmakuri Davidsen <soren@atmakuridavidsen.com>
License: MIT
License-File: LICENSE
Keywords: fuzzy logic,fuzzy systems,machine learning,scikit-learn
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Scientific/Engineering :: Information Analysis
Requires-Python: >=3.12
Requires-Dist: numpy>=1.17
Requires-Dist: scikit-learn>=0.22
Provides-Extra: scipy
Requires-Dist: scipy>=1.3; extra == 'scipy'
Description-Content-Type: text/markdown

<img src="docs/img/fylearn.svg" alt="fylearn - fuzzy machine learning" width="300">

[![Build status](https://github.com/sorend/fylearn/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/sorend/fylearn/actions/?query=branch%3Amain)
[![PyPI version](https://badge.fury.io/py/fylearn.svg)](https://badge.fury.io/py/fylearn)
[![CodeQL](https://github.com/sorend/fylearn/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/sorend/fylearn/actions/workflows/codeql-analysis.yml)
[![Codecov](https://codecov.io/gh/sorend/fylearn/branch/main/graph/badge.svg)](https://codecov.io/gh/sorend/fylearn)

fylearn is a fuzzy machine learning library, built on top of [SciKit-Learn](http://scikit-learn.org/).

SciKit-Learn contains many common machine learning algorithms, and is a good place to start if you want to play or program anything related to machine learning in Python. fylearn is not intended to be a replacement for SciKit-Learn (in fact fylearn depends on SciKit-Learn), but to provide an extra set of machine learning algorithms from the fuzzy logic community.

Machine learning algorithms
---------------------------

### Fuzzy pattern classifiers

Fuzzy pattern classifiers are classifiers that describe data using fuzzy sets and fuzzy aggregation functions.

Several fuzzy pattern classifiers are implemented in the library:

 - fylearn.fpcowa.FuzzyPatternClassifier -- base classifier with OWA-based aggregation (see parameters).
 - fylearn.fpcowa.MultipleAggregationsFuzzyPatternClassifier -- combines several aggregations in a single classifier.
 - fylearn.fpcga.FuzzyPatternClassifierGA -- optimizes membership functions globally using a genetic algorithm.
 - fylearn.fpcga.FuzzyPatternClassifierLGA -- optimizes membership functions locally using a genetic algorithm.
 - fylearn.fpcga.SEFuzzyPatternClassifier -- fuzzy pattern classifier with membership functions optimized by search effort.
 - fylearn.fpt.FuzzyPatternTreeClassifier -- builds fuzzy pattern trees using bottom-up method.
 - fylearn.fpt.FuzzyPatternTreeTopDownClassifier -- builds fuzzy pattern trees using top-down method.
 - fylearn.frr.FuzzyReductionRuleClassifier -- based on learning membership functions from min/max.
 - fylearn.frr.ModifiedFuzzyPatternClassifier -- reduction-rule classifier using OWA / AIWA operators.
 - fylearn.rafpc.RandomAgreementFuzzyPatternClassifier -- builds fuzzy pattern classifiers using agreement-based random sampling.

### Genetic Algorithm rule based classifiers

A type of classifier that uses GA to optimize rules:

 - fylearn.garules.MultimodalEvolutionaryClassifier -- learns rules using genetic algorithm.
 - fylearn.garules.EnsembleMultimodalEvolutionaryClassifier -- ensemble of multimodal evolutionary classifiers.

### ANFIS

 - fylearn.anfis.AnfisClassifier -- Adaptive-Network-based Fuzzy Inference System classifier (Jang, 1993).

Installation
------------

You can add fylearn to your project by using pip:

    pip install fylearn

For development, install the dependencies and run the tests with [uv](https://docs.astral.sh/uv/):

    uv sync
    uv run make test

### Usage

You can use the classifiers as any other SciKit-Learn classifier:

```python
from sklearn.datasets import load_iris
from fylearn.anfis import AnfisClassifier
from fylearn.fpcowa import FuzzyPatternClassifier
from fylearn.fpt import FuzzyPatternTreeTopDownClassifier
from fylearn.garules import MultimodalEvolutionaryClassifier

X, y = load_iris(return_X_y=True)

C = (FuzzyPatternClassifier(),
     MultimodalEvolutionaryClassifier(n_iterations=100),
     FuzzyPatternTreeTopDownClassifier(),
     AnfisClassifier())

for c in C:
    print(type(c).__name__, c.fit(X, y).predict(X[:5]))
```

Heuristic search methods
------------------------

Several heuristic search methods are implemented. These are used in the learning algorithms
for parameter assignment, but, are also usable directly.

 - fylearn.local_search.PatternSearchOptimizer
 - fylearn.local_search.LocalUnimodalSamplingOptimizer
 - fylearn.ga.GeneticAlgorithm: Search parameters using modification and a scaling
 - fylearn.ga.UnitIntervalGeneticAlgorithm: Search parameters in unit interval universe.
 - fylearn.ga.DiscreteGeneticAlgorithm: Search parameters from discrete universe.
 - fylearn.tlbo.TeachingLearningBasedOptimizer: Search using teaching-learning based optimization.
 - fylearn.jaya.JayaOptimizer: Search based on moving towards best solution while avoiding worst.

Example use:

```python
import numpy as np
from fylearn.ga import UnitIntervalGeneticAlgorithm, helper_fitness, helper_n_generations
from fylearn.local_search import LocalUnimodalSamplingOptimizer, helper_num_runs
from fylearn.tlbo import TeachingLearningBasedOptimizer
from fylearn.jaya import JayaOptimizer

def fitness(x):  # defined for a single chromosome, so we need helper_fitness for GA
    return np.sum(x**2)

ga = UnitIntervalGeneticAlgorithm(fitness_function=helper_fitness(fitness), n_chromosomes=100, n_genes=10)
ga = helper_n_generations(ga, 100)
best_chromosomes, best_fitness = ga.best(1)
print("GA solution", best_chromosomes[0], "fitness", best_fitness[0])

lower_bounds, upper_bounds = np.ones(10) * -10.0, np.ones(10) * 10.0
lus = LocalUnimodalSamplingOptimizer(fitness, lower_bounds, upper_bounds)
best_solution, best_fitness = helper_num_runs(lus, 100)
print("LUS solution", best_solution, "fitness", best_fitness)

tlbo = TeachingLearningBasedOptimizer(f=fitness, lower_bound=lower_bounds, upper_bound=upper_bounds)
tlbo = helper_n_generations(tlbo, 100)
best_solution, best_fitness = tlbo.best()
print("TLBO solution", best_solution, "fitness", best_fitness)

jaya = JayaOptimizer(f=fitness, lower_bound=lower_bounds, upper_bound=upper_bounds)
jaya = helper_n_generations(jaya, 100)
best_solution, best_fitness = jaya.best()
print("Jaya solution", best_solution, "fitness", best_fitness)
```

A tiny fuzzy logic library
--------------------------

Tiny, but hopefully useful. The focus of the library is on providing membership functions and aggregations that work with NumPy, for using in the implemented learning algorithms.

### Membership functions

 - fylearn.fuzzylogic.TriangularSet
 - fylearn.fuzzylogic.TrapezoidalSet
 - fylearn.fuzzylogic.PiSet
 - fylearn.fuzzylogic.ZadehNegatedSet
 - fylearn.nonstationary.NonstationaryFuzzySet

Example use:

```python
import numpy as np
from fylearn.fuzzylogic import TriangularSet
t = TriangularSet(1.0, 4.0, 5.0)
print(t(3))   # use with singletons
print(t(np.array([[1, 2, 3], [4, 5, 6]])))  # use with arrays
```

### Aggregation functions

Here focus has been on providing aggregation functions that support aggregation along a specified axis for 2-dimensional matrices.

Example use:

```python
import numpy as np
from fylearn.fuzzylogic import meowa, OWA
a = OWA(np.array([1.0, 0.0, 0.0]))  # pure AND in OWA
X = np.random.rand(5, 3)
print(a(X))  # AND row-wise
a = meowa(5, 0.2)  # OR, orness = 0.2
print(a(X.T))  # works column-wise, so apply to transposed X
```

Also available: t-norms / t-conorms (product, mean, min, max, Lukasiewicz, Einstein, algebraic sum),
OWA variants (GOWA, weights_mapping, sampling_owa_orness), and andness-directed averaging
(fylearn.fuzzylogic.AndnessDirectedAveraging).

To Do
-----

We are working on adding the following algorithms:

 - FRBCS.

About
-----

fylearn is supposed to mean "FuzzY learning", but in Danish the word "fy" means loosely translated "for shame". It has been created by the Department of Computer Science at Sri Venkateswara University, Tirupati, INDIA by a [PhD student](http://www.cs.svu-ac.in/~sorend/) as part of his research.

Contributions:
--------------

 - fylearn.local_search Python code by [M. E. H. Pedersen](http://hvass-labs.org/) (M. E. H. Pedersen, *Tuning and Simplifying Heuristical Optimization*, PhD Thesis, University of Southampton, U.K., 2010)
