scikit-fuzzy

Common errors

• AttributeError: 'module' object has no attribute 'Antecedent'

  cause The `Antecedent` class, along with other control system components, is located in the `skfuzzy.control` submodule, not directly in the `skfuzzy` top-level package.
  fix Change your import statement to `from skfuzzy import control as ctrl` and then use `ctrl.Antecedent(...)`.

• ValueError: Unexpected input: <variable_name>

  cause This error typically occurs when initializing `Antecedent` or `Consequent` objects within `skfuzzy.control`. It signifies a mismatch in the variable name provided as input to `ControlSystemSimulation.input` or incorrect definition of the control system variables.
  fix Double-check that the string names passed to `ctrl.Antecedent('name', ...)` and `ctrl.Consequent('name', ...)` exactly match the keys used when setting input values to a `ControlSystemSimulation` instance (e.g., `sim.input['name'] = value`). Also verify the type and range of the input provided to `Antecedent` or `Consequent` constructor matches expected `np.arange` or similar.

• AssertionError: fuzzy system python assertion error during input

  cause While some related reports mention `fuzzywuzzy`, similar assertion errors in `scikit-fuzzy` often arise from incorrect definition of universe variables, membership functions, or fuzzy rules, leading to invalid input during computation or inference. This can include non-overlapping membership functions or improper ranges.
  fix Review the definitions of your universe variables (`np.arange`), membership functions (`fuzz.trimf`, `fuzz.gaussmf`, etc.), and fuzzy rules. Ensure that membership functions cover the expected range of inputs and that rules are logically consistent. Pay close attention to the input values provided to the `compute()` method of a `ControlSystemSimulation`.

Warnings

• breaking scikit-fuzzy adheres to the IEEE standard for rounding, which can lead to slight numerical differences compared to MATLAB's rounding behavior (e.g., 2.5 rounds to 2, 3.5 rounds to 4). If re-implementing algorithms from MATLAB, expect minor inconsistencies due to this.
  Fix: Be aware of the IEEE rounding standard when comparing results with MATLAB. This is intentional and not considered a bug.
• breaking The fuzzy control system API (within `skfuzzy.control`) underwent significant changes and improvements in earlier major releases (e.g., 0.3.0 introduced a new API). Older implementations of fuzzy control systems might require updates to use the new `Antecedent`, `Consequent`, `ControlSystem`, and `ControlSystemSimulation` classes.
  Fix: Consult the `skfuzzy.control` documentation and examples for the current API. Update control system definitions to use `ctrl.Antecedent`, `ctrl.Consequent`, etc., and leverage `ControlSystemSimulation` for computations.
• gotcha Classes and functions related to fuzzy control systems (e.g., `Antecedent`, `Consequent`, `ControlSystem`) are *not* directly available in the main `skfuzzy` namespace. They must be explicitly imported from the `skfuzzy.control` submodule.
  Fix: Always use `from skfuzzy import control as ctrl` to access fuzzy control system components, then reference them as `ctrl.Antecedent`, `ctrl.Consequent`, etc.
• gotcha There have been reports of compatibility issues with Python 3.12, often surfacing through underlying dependency conflicts. While `scikit-fuzzy` aims for broad Python support, specific environment configurations with Python 3.12 might encounter problems.
  Fix: If encountering issues with Python 3.12, consider using Python 3.11 or earlier. Monitor `scikit-fuzzy`'s GitHub for updates on Python 3.12 compatibility. Ensure all dependencies are up-to-date and compatible with your Python version.

Install

• pip install -U scikit-fuzzy PyPI (recommended)
• conda install -c conda-forge scikit-fuzzy Anaconda/Conda-forge

Imports

• skfuzzy
  wrong:

  import skfuzzy

  correct:

  import skfuzzy as fuzz

  The common and recommended practice is to import `skfuzzy` with the alias `fuzz` for brevity and consistency with examples.
• control
  wrong:

  import skfuzzy.control

  correct:

  from skfuzzy import control as ctrl

  Classes for building fuzzy control systems (e.g., `Antecedent`, `Consequent`, `ControlSystem`) reside in the `control` submodule and are typically aliased as `ctrl`.
• numpy

  import numpy as np

  Often used alongside scikit-fuzzy for defining universe variables and membership functions.
• pyplot

  from matplotlib import pyplot as plt

  Frequently used for visualizing fuzzy sets, membership functions, and control surfaces.

Quickstart

This quickstart demonstrates how to define a universe of discourse using NumPy and then create triangular fuzzy membership functions using `fuzz.trimf`. It then plots these membership functions using Matplotlib to visualize the fuzzy sets. This is a fundamental step in building any fuzzy logic system with scikit-fuzzy.

import numpy as np
import skfuzzy as fuzz
import matplotlib.pyplot as plt

# Generate universe variables
x = np.arange(0, 11, 1) # Points from 0 to 10

# Generate fuzzy membership functions
low = fuzz.trimf(x, [0, 0, 5])
medium = fuzz.trimf(x, [0, 5, 10])
high = fuzz.trimf(x, [5, 10, 10])

# Visualize these universes and membership functions
plt.figure()
plt.plot(x, low, 'b', linewidth=1.5, label='Low')
plt.plot(x, medium, 'g', linewidth=1.5, label='Medium')
plt.plot(x, high, 'r', linewidth=1.5, label='High')
plt.title('Fuzzy Membership Functions')
plt.ylabel('Membership value')
plt.xlabel('Universe Variable')
plt.legend()
plt.grid(True)
plt.show()