Question

我想创建一个将Activation Function应用于值的类。该课程如下

public class ActivationFunction {

    public static double function(double value, Functions functions) {
        if(functions.equals(Functions.SIGMOID)) {
            return sigmoid(value);
        }
        return 0f;
    }
    public static double derivativeOfFunction(double value, Functions functions) {
        if(functions.equals(Functions.SIGMOID))
            return sigmoidDerivative(value);

        return 0f;
    }

    private static double sigmoid(double value) {
        return 1 / (1 + Math.exp(0 - value));
    }
    private static double sigmoidDerivative(double value) {
        return ( Math.exp(0 - value) / ( (1 + Math.exp(0 - value)) * (1 + Math.exp(0 - value)) ) );
    }

}

Functions是enum，其中定义了不同的函数。现在只有sigmoid功能，但会添加更多功能。

问题

我认为它违反了Open-Closed Principle，OOP的5个SOLID原则之一（可能是它违反了更多）。那么，编写这个类以便在将来添加更多函数的正确方法是什么？

感谢任何帮助。

Answer 1

您可以将公共接口的实现放在枚举本身中。

这样的事情：

public enum Functions {
  SIGMOID {
    public double function(double value) { return 1 / (1 + Math.exp(0 - value)); }
    public double derivative(double value) { return ...; }
  },
  OTHER_FUNCTIONS { ... }

  public abstract double function(double value);
  public abstract double derivative(double value);
}

然后你的ActivationFunction变得非常简单 - 它甚至可能都不再有用了。

Answer 2

如此给出enum值的行为怎么样？

enum MyFunctions {
    FUNC_1 {
        @Override double compute(double value) {
            return 1 / (1 + Math.exp(0 - value));
        }
    },

    FUNC_2 {
        @Override double compute(double value) {
            return ( Math.exp(0 - value) / ( (1 + Math.exp(0 - value)) * (1 + Math.exp(0 - value)) ) );
        }
    };

    abstract double compute(double value);
}

每当您需要更多功能时，请定义另一个枚举值，例如FUNC_3。如果您需要多个方法compute，请添加另一种方法compute2。

我选择的所有名字都很愚蠢，但我希望你明白这一点。或者我完全错过了你的问题的目标？

Answer 3

这是我的解决方案：

public interface Function {
    double doIt(double value);
}

public class Sigmoid implements Function {
    @Override
    public double doIt(double value) {
        return 0;
    }
}

public class ActivationFunction {
    public static double callFunction(Function function,double value){
        return function.doIt(value);
    }
}

您应该为新函数创建一个新类并实现Function接口。 callFunction参数类型Function，因此您在添加新函数时无需更改它，并且Open-Closed Principle正确。

遵循所有SOLID原则的正确版本的类

3 个答案: