Flutter神经网络框架插件neural_network_skeleton的使用

neural_network_skeleton 是一个用于构建全连接神经网络的Flutter插件，基于前馈算法。它提供了构建神经网络的基本组件，并可以根据给定输入输出一组值。

基本用法

逻辑 OR

下面是一个简单的示例，展示了如何使用 neural_network_skeleton 来实现逻辑 OR：

const orPerceptron = Perceptron(
  bias: 0.0,
  threshold: 1.0,
  weights: [1.0, 1.0],
);

final neuralNetwork = NeuralNetwork(
  layers: const [
    PerceptronLayer(
      perceptrons: [
          orPerceptron,
      ],
    )
  ],
);

neuralNetwork.guess(inputs: [0.0, 0.0]); // [0.0]
neuralNetwork.guess(inputs: [1.0, 0.0]); // [1.0]
neuralNetwork.guess(inputs: [0.0, 1.0]); // [1.0]
neuralNetwork.guess(inputs: [1.0, 1.0]); // [1.0]

逻辑 AND & 逻辑 XOR

对于逻辑 AND 和逻辑 XOR 的实现，请参考 GitHub 示例文件。

完整示例 Demo

以下是一个完整的 Flutter 应用程序示例，展示了如何使用 neural_network_skeleton 实现逻辑 OR、AND 和 XOR：

import 'package:flutter/material.dart';
import 'package:neural_network_skeleton/neural_network_skeleton.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  [@override](/user/override)
  Widget build(BuildContext context) {
    return const MaterialApp(home: MyHomePage());
  }
}

class MyHomePage extends StatelessWidget {
  const MyHomePage({
    super.key,
  });

  [@override](/user/override)
  Widget build(BuildContext context) {
    List<List<double>> logicalInputsList = [
      [0.0, 0.0],
      [1.0, 0.0],
      [0.0, 1.0],
      [1.0, 1.0],
    ];

    final List<Widget> textRows = [];

    // ============ LOGICAL OR NEURAL NETWORK ==================================
    const orPerceptron = Perceptron(
      bias: 0.0,
      threshold: 1.0,
      weights: [1.0, 1.0],
    );

    final orNeuralNetwork = NeuralNetwork(
      layers: [
        PerceptronLayer(
          perceptrons: const [
            orPerceptron,
          ],
        )
      ],
    );

    textRows.add(const Text('===== Logical OR ====='));
    textRows.add(const Text('    Inputs       Outputs'));
    for (List<double> inputs in logicalInputsList) {
      final output = orNeuralNetwork.guess(inputs: inputs);
      textRows.add(Text('$inputs        $output'));
    }

    // ============ LOGICAL AND NEURAL NETWORK =================================
    const andPerceptron = Perceptron(
      bias: 0.0,
      threshold: 1.0,
      weights: [0.5, 0.5],
    );

    final andNeuralNetwork = NeuralNetwork(
      layers: [
        PerceptronLayer(
          perceptrons: const [
            andPerceptron,
          ],
        )
      ],
    );

    textRows.add(const SizedBox(height: 24));
    textRows.add(const Text('===== Logical AND ====='));
    textRows.add(const Text('    Inputs       Outputs'));
    for (List<double> inputs in logicalInputsList) {
      final output = andNeuralNetwork.guess(inputs: inputs);
      textRows.add(Text('$inputs        $output'));
    }

    // ============ LOGICAL XOR NEURAL NETWORK =================================
    const notPerceptron = Perceptron(
      bias: 1.0,
      threshold: 0.0,
      weights: [0.0, -1.0],
    );
    const passthroughPerceptron = Perceptron(
      bias: 0.0,
      threshold: 0.0, // Sigmoid prevents 1.0
      weights: [1.0, 0.0],
    );

    final xorNeuralNetwork = NeuralNetwork(layers: [
      PerceptronLayer(
        perceptrons: const [
          orPerceptron,
          andPerceptron,
        ],
      ),
      PerceptronLayer(
        perceptrons: const [
          passthroughPerceptron,
          notPerceptron,
        ],
      ),
      PerceptronLayer(
        perceptrons: const [
          andPerceptron,
        ],
      ),
    ]);

    textRows.add(const SizedBox(height: 24));
    textRows.add(const Text('===== Logical XOR ====='));
    textRows.add(const Text('    Inputs       Outputs'));
    for (List<double> inputs in logicalInputsList) {
      final output = xorNeuralNetwork.guess(inputs: inputs);
      textRows.add(Text('$inputs        $output'));
    }

    return Scaffold(
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: textRows,
        ),
      ),
    );
  }
}