Question

我已经搜索了很多，我还没有找到任何显示任何使用swift实现神经网络的东西。我打算使用swift构建一个涉及神经网络使用的应用程序。所以我想知道我是否可以得到任何帮助。如果有任何关于swift神经网络的文档，如果有人提供一些参考，我会很高兴。

Answer 1

当然有办法。这是我的版本，在Swift中使用反向传播的简单神经网络

import Foundation


public extension ClosedRange where Bound: FloatingPoint {
    public func random() -> Bound {
        let range = self.upperBound - self.lowerBound
        let randomValue = (Bound(arc4random_uniform(UINT32_MAX)) / Bound(UINT32_MAX)) * range + self.lowerBound
        return randomValue
    }
}

public class Layer {

    private var output: [Float]
    private var input: [Float]
    private var weights: [Float]
    private var previousWeights: [Float]

    init(inputSize: Int, outputSize: Int) {
        self.output = [Float](repeating: 0, count: outputSize)
        self.input = [Float](repeating: 0, count: inputSize + 1)
        self.weights = (0..<(1 + inputSize) * outputSize).map { _ in
            return (-2.0...2.0).random()
        }
        previousWeights = [Float](repeating: 0, count: weights.count)
    }

    public func run(inputArray: [Float]) -> [Float] {

        for i in 0..<inputArray.count {
            input[i] = inputArray[i]
        }

        input[input.count-1] = 1
        var offSet = 0

        for i in 0..<output.count {
            for j in 0..<input.count {
                output[i] += weights[offSet+j] * input[j]
            }

            output[i] = ActivationFunction.sigmoid(x: output[i])
            offSet += input.count

        }

        return output
    }

    public func train(error: [Float], learningRate: Float, momentum: Float) -> [Float] {

        var offset = 0
        var nextError = [Float](repeating: 0, count: input.count)

        for i in 0..<output.count {

            let delta = error[i] * ActivationFunction.sigmoidDerivative(x: output[i])

            for j in 0..<input.count {
                let weightIndex = offset + j
                nextError[j] = nextError[j] + weights[weightIndex] * delta
                let dw = input[j] * delta * learningRate
                weights[weightIndex] += previousWeights[weightIndex] * momentum + dw
                previousWeights[weightIndex] = dw
            }

            offset += input.count
        }

        return nextError
    }

}

import Foundation

public class ActivationFunction {

    static func sigmoid(x: Float) -> Float {
        return 1 / (1 + exp(-x))
    }

    static func sigmoidDerivative(x: Float) -> Float {
        return x * (1 - x)
    }

}

import Foundation

public class NeuralNetwork {

    public static var learningRate: Float = 0.3
    public static var momentum: Float = 0.6
    public static var iterations: Int = 70000

    private var layers: [Layer] = []

    public init(inputSize: Int, hiddenSize: Int, outputSize: Int) {
        self.layers.append(Layer(inputSize: inputSize, outputSize: hiddenSize))
        self.layers.append(Layer(inputSize: hiddenSize, outputSize: outputSize))
    }

    public func run(input: [Float]) -> [Float] {

        var activations = input

        for i in 0..<layers.count {
            activations = layers[i].run(inputArray: activations)
        }

        return activations
    }

    public func train(input: [Float], targetOutput: [Float], learningRate: Float, momentum: Float) {

        let calculatedOutput = run(input: input)

        var error = zip(targetOutput, calculatedOutput).map { $0 - $1 }

        for i in (0...layers.count-1).reversed() {
            error = layers[i].train(error: error, learningRate: learningRate, momentum: momentum)
        }

    }

}

您可以使用这些学习AND逻辑运算符的输入数据进行检查：

let traningData: [[Float]] = [ [0,0], [0,1], [1,0], [1,1] ]

let traningResults: [[Float]] = [ [0], [0], [0], [1] ]

let backProb = NeuralNetwork(inputSize: 2, hiddenSize: 3, outputSize: 1)

for iterations in 0..<NeuralNetwork.iterations {

    for i in 0..<traningResults.count {
        backProb.train(input: traningData[i], targetOutput: traningResults[i], learningRate: NeuralNetwork.learningRate, momentum: NeuralNetwork.momentum)
    }

    for i in 0..<traningResults.count {
        var t = traningData[i]
        print("\(t[0]), \(t[1])  -- \(backProb.run(input: t)[0])")
    }

}

Answer 2

Bender允许您在iOS上构建和运行神经网络。因为它在引擎盖下使用金属，它运行快速和平稳。它还支持直接运行TensorFlow模型。

免责声明：我参与了这个项目。

Answer 3

你可以看看这个库 - Swift-AI，一个完全用Swift编写的机器学习库，支持iOS和OS X.另一个这样的库是Swift Brain。

有关iOS机器学习的大量其他有用信息可以在here找到。

另外，作为旁注，如果您只想构建使用iOS机器学习模型的应用程序，您可以随时在云或其他系统上训练您的模型，并将它们加载到您的应用程序中并使用它们，您需要没有在Swift中实现神经网络。

Answer 4

几个机器学习库（包括像caffe或tensorflow这样的神经网络特定库）是用C ++编写的。使用C ++在性能方面具有一些优势，除了它是科学领域的通用语言。在Python或Swift等任何其他编程语言中使用这些库可以通过为它们创建包装器来实现。

因此，如果您不想在Swift中实现神经网络库，我的建议如下：

找一个适合您的问题陈述的深度学习库，以及您对此感到满意的
熟悉包装类
实现您的包装类并在Swift项目中使用用C ++编写的机器学习库

此外，搜索用Swift编写的机器学习库也给出了一些合理的结果，如上所述：Swift-AI或Swift-Brain。

无论如何使用swift为ios实现神经网络？

4 个答案: