神经网络原型设计
根据您的经验，哪种是实现人工神经网络原型最有效的方法？关于 R （免费，但我没有使用它）或 Matlab 有很多炒作（不是免费的），另一种可能的选择是使用 C++/Java/C# 等语言。这个问题主要针对那些试图测试某些神经网络架构或学习算法的人。
如果您选择使用与上述三种不同的编程语言，您能否告诉我它们的名称以及有关您选择的一些解释（例外：这是我所知道的唯一/最常用的语言）。
谢谢。
from your experience, which is the most effective approach to implement artificial neural networks prototypes? It is a lot of hype about R (free, but I didn't work with it) or Matlab (not free), another possible choice is to use a language like C++/Java/C#. The question is mainly targeting the people that tried to test some neural networks architectures or learning algorithms.
If your choice is to use a programming language different from the three mentioned above, can you tell me their names and some explanations concerning your choice (excepting: this is the only/most used language known by me).
Thanks.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（18）
由于神经网络被科学家大量使用，而不是程序员使用得那么多，因此选择一种针对科学家并为神经网络提供良好库的编程语言。
Python 是一个合理的选择，因为它被科学家广泛使用。首先可以使用的两个发行版是
http://www.pythonxy.com/
http://code.enthought.com/
这些 Python 发行版包含许多附加模块，这些模块不在标准 Python 库中，但这对于科学家所做的编程类型非常有用。搜索 Python 包索引会找到一些神经网络包，如果您刚刚学习神经网络，这些包可能没问题。
http://pypi.python.org/pypi?: action=search&term=neural&submit=search
但是，如果您正在认真使用神经网络，您将需要像快速神经网络库这样的东西。它附带了 Python 绑定，以便您可以使用 Python 进行编程，使用各种 Python 模块进行绘图、可视化、数据操作等。但是，您的神经网络将使用 FANN 库中优化编译的代码运行。两全其美。
换句话说，为了运行实际的神经网络代码，您需要 C，而不是 Java。由于 C 库与 Java 的集成不太好，因此请选择一种能够与 C 库顺利集成的语言。 Python 可以做到这一点，并且比 Java 更有效率，因为解释算法所需的代码行少得多。有些人发现它的生产力比 Java 提高了 10 倍。
您提到 R，可能是因为它具有您需要使用的统计函数，或者您可能有人可以编写 R 代码。再次强调，选择 Python 还是 R 并不是一个非此即彼的决定。您可以同时使用两者。
RPY 库允许 Python 程序访问 R 库和代码。使用它，您可以用 Python 编写主程序，并将 R 视为提供库的工具，就像使用用 C 编写的 FANN 库一样。
https://rpy2.github.io/
还有一个名为 RSPython 的模块可以双向工作，这样 R 程序就可以访问用 Python 编写的库。如果您有专业的 R 程序员帮助您，这将会很有用。
http://www.omegahat.org/RSPython/
这还不是全部。您可以利用 Python 来简化 Java 编程。如果您有 Java 神经网络引擎，您仍然可以使用 Jython 版本在 Python 中编写大部分程序，该版本在 Java VM 上运行，并允许您在代码中使用任何 Java 库和类。您仍然可以使用快速 FANN 库，因为它们提供了 Java 程序的绑定。
我推荐 Python 用于您的工作的主要原因是它被大量科学家使用，这就是为什么有两个面向科学的发行版可用。第二个原因是，Python 对于新手程序员来说非常容易上手，在探索神经网络时，您可能会从更简单的模拟开始，然后通过更多的数据操作和结果分析逐步达到更复杂的模拟。 Python将允许你建立自己的代码库，并成为一名专家Python程序员，这样你就可以将更多的注意力集中在神经网络问题上。如果您熟悉一点 Java、一点 C++ 和一点 R，那么您将能够在神经网络上花费更少的时间。这种策略可能适合那些想要从事编程职业的人，但不适合那些想要通过神经网络取得一些重大成果的人。
即使您的神经网络工作扩展到专用硬件（即所谓的神经形态芯片），您仍然可以利用 Python，如 NIH 的这篇论文所示：
http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2701676/
Since neural networks are used a lot by scientists, and not so much by programmers, choose a programming language that targets scientists and provides good libraries for neural networks.
Python is a reasonable choice since it is widely used by scientists. Two distributions to start with are
http://www.pythonxy.com/
http://code.enthought.com/
These Python distributions include a lot of add-on modules that are not in the standard Python library but which are very useful for the type of programming that scientists do. Searching the Python package index comes up with a few neural network packages that may be OK if you are just learning about neural networks.
http://pypi.python.org/pypi?:action=search&term=neural&submit=search
However, if you are doing serious work with Neural Networks you will want something like the Fast Neural Network library. This comes with Python bindings so that you can do your programming in Python, use the wide variety of Python modules for graphing, visualisation, data manipulation and so on. But, your neural networks will run using optmised compiled code from the FANN library. The best of both worlds.
In other words, for running the actual neural network code, you need C, not Java. Since C libraries don't integrate that well with Java, choose a language that does integrate smoothly with C libraries. Python does that and is also rather more productive than Java since there is a lot less lines of code required to explain your algorithms. Some people have found a 10 times increase in productivity over Java.
You mentioned R, perhaps because it has statistical functions that you would need to use, or perhaps you have people available who can write R code. Again, choosing Python versus R is not an either-or decision. You can use both.
The RPY library allows Python programs to access R libraries and code. Using this you would write your main programs in Python and treat R as a tool to provide libraries, in the same way that you make use of the FANN library which was written in C.
https://rpy2.github.io/
There is another module called RSPython that works both ways, so that R programs can access libraries written in Python. This would be useful if you have an expert R programmer helping you.
http://www.omegahat.org/RSPython/
And that's not all. You can leverage Python to simplify Java programming. If you have a Java neural network engine, you can still write most of your program in Python using the Jython version which runs on the Java VM and allows you to use any Java libraries and classes in your code. And you can still use the fast FANN library as well since they provide bindings for Java programs.
The main reason that I recommend Python for your work is that it is used by an awful lot of scientists which is why there are two science oriented distributions available. A second reason is that Python is very easy for novice programmers to get started with, and in exploring neural networks you will probably start with simpler simulations and work up to more complex ones with more data manipulation and analysis of results. Python will allow you to build up your own library of code, and become an expert Python programmer so that you can focus more of your attention on the neural network problems. If you bounce around with a bit of Java, and a bit of C++ and a bit of R, then you will be able to spend less time on neural networks. That strategy might be good for someone who wants a career in programming, but not for someone who wants to achieve some significant results with neural networks.
Even if your neural network work extends into specialised hardware, so-called neuromorphic chips, you can still leverage Python as this paper from the NIH demonstrates:
http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2701676/
我尝试使用较高抽象级别的语言（matlab、java）和较低抽象级别的语言（C）。两者都使用工具箱和库并自己编码。总体反应如何？两者都不是完美的工具。请记住：
原型可能还不够：通常您需要在大样本上运行网络，或者在样本子集上运行几次（在不断发展的神经网络的情况下）才能获得不错的结果。如果您必须运行网络一百万次，即使是很小的性能提升也可能会带来巨大的帮助并节省时间（即通过 matlab 进行 C 语言）；
另一方面，如果您需要轻松编码，您可能需要使用许多预打包库（javaNN 等）之一；
您使用哪种神经网络？连续时间循环神经网络（CTRNN）？反向传播？你如何训练他们？您如何验证他们的结果？准确性重要吗？ （即，您是否在小型设备上运行它们，例如内存有限的机器人控制板，如 Arduino？）
如果您有空闲时间，我建议您
希望这会有所帮助。
I tried using both higher-abstraction level languages (matlab, java) and lower ones (C). Both using toolboxes and libraries and coding them myself. The overall response? Neither is the perfect tool. Please keep in mind that:
a prototype might not be enough: often you need to run the network over large samples, or several times over a subset of samples (in case of evolving neural networks) to get decent results. If you have to run a network a million times, even a small performance gain might be a huge help and time-saver (i.e. C over matlab);
if, on the other hand, you need ease of coding you might want to use one of the many pre-packaged libraries (javaNN, etc);
what kind of neural network are you using? continuous-time recurring neural networks (CTRNN)? Backprop? How do you do train them? How do you verify their results? Is accuracy important? (i.e. are you running them on a small device, such as a memory-limited robotic control board, like Arduinos?)
If you have time to spare, I'd suggest
Hope this helps.
我在某种程度上使用了 Matlab 的神经网络工具箱，并且喜欢将其作为原型设计工具，因为它的图形界面允许您设置网络、试验训练与测试输入数据的大小以及训练后测试所有内容内置的。开始使用似乎很好很自然...
我还尝试了 Joone （Java 对象面向神经引擎）。
它的设置非常好，当时我还是一个业余爱好者，但通过测试仍然没有问题地设置和运行各种网络。
它是 Java，因此如果您正在训练大型复杂系统，它可能不具备您可能想要的性能，但它的 API 非常平易近人。
我还看到了一些用 C++ 中的 Flood 完成的工作。它有很多用网络设置的类，适合解决一系列问题。值得一试。
I have used Matlab's Neural networking tool box to some extent, and enjoyed it as a prototyping tool due to its graphic interface to allow you to set up the network, experiment with sizes of training vs test input data, and its post-training testing all built in. It just seemed nice and natural to get started with...
I also experimented with Joone (Java Object Oriented Neural Engine).
It is set up quite nicely, and at the time I was a bit of an amateur and still had no problems getting various networks up and running, with testing.
It is Java, so it may not have the performance that you might want if you are training large complex systems, but its API was extremely approachable.
I have also seen some work done with Flood in C++. It has a bunch of classes set up with networks that are appropriate to solve a range of problems. It is worth checking out.
我也强烈推荐Python。对于原型来说，Python 是一个不错的选择：它的编程更容易、更快，有大量可用的库，并且在科学界广泛使用。
另外，如果您使用 python，您还可以利用优秀的 PyBrain 包，其中包含神经网络算法、强化学习、无监督学习和其他机器学习任务，这应该可以帮助您快速构建原型。
I would also highly recommend python. For a prototype, python is a great choice: it is easier and faster to program in, there are a huge number of libraries available, and it widely used in the scientific community.
Also, if you are using python, you can also take advantage of the excellent PyBrain package which contains algorithms for neural networks, reinforcement learning, unsupervised learning, and other machine learning tasks, which should help you build a prototype quickly.
这取决于您当前的设置。当我在大学时代研究它们时，我必须使用 C++ + MPI+数值方法。这样做是因为我必须在大型 Beowulf 集群上加载共享。
如果你的计算需求不大，什么都可以。预打包库可在所有平台上使用（R、Python（numPy、scipy）、C/C++（数值配方）等）。如果您可以轻松地使用其中任何一种进行编程，那么这应该不是什么大问题。
如果我现在必须对任何东西进行原型设计，我可能会选择 Python（只是因为我发现它更容易进行原型设计）
This depends on your current setup. When I used to work on them back in college days, I had to use C++ + MPI+numerical recipes. This was done because I had to load share on big beowulf cluster.
If your computation needs are not big, anything would do. Prepackaged libraries are available on all the platforms (R, Python(numPy, scipy), C/C++(Numerical recipes) etc). If you are comfortable programming in any one of them, it should not be a big deal.
If I had to prototype anything now, I'd probably go with Python (just because I find it much more easier for prototyping)
Scilab 是 Matlab 的开源替代品。
您可以使用ANN Toolbox for Scilab。
注重理论和实验。您是否为样本选择了判别特征？您的训练和测试集的状态如何。对于每个实验，研究混淆矩阵。您知道为什么样本会被错误分类吗？你觉得这符合逻辑吗？如果没有，您不使用哪个功能会有帮助？
接下来是实施，使用您熟悉的语言。像 Java 或 C# 这样的托管语言可能不太容易出错：至少你不太可能因为指针或内存分配错误而搞砸事情。优化是最后的（一如既往地进行一些不错的分析之后）。
Scilab is an open source alternative to Matlab.
You may experiment with neural networks using the ANN Toolbox for Scilab.
Focus on the theory and experiments. Did you choose discriminant features for your samples? What's the state of your training and test sets. For each experiment, study the confusion matrix. Do you have an idea why a sample is misclassified? Does it seem logical to you? If not, which feature you don't use would help?
Implementing comes next, use the language you're familiar with. A managed language like Java or C# is likely to be less error prone: at least you're less likely to screw up things because of pointer or memory allocation bugs. Optimizing comes last (after some decent profiling as always).
“Encog 是一种先进的神经网络和机器学习框架。Encog 包含用于创建各种网络的类，以及用于规范化和处理这些神经网络数据的支持类。Encog 使用多线程弹性传播进行训练。Encog 还可以利用自 2008 年以来，Encog 一直在积极开发基于 GUI 的工作台来帮助建模和训练神经网络。”
Encog 可用于 Java、C#.Net 和 Silverlight。
http://www.heatonresearch.com/encog
"Encog is an advanced neural network and machine learning framework. Encog contains classes to create a wide variety of networks, as well as support classes to normalize and process data for these neural networks. Encog trains using multithreaded resilient propagation. Encog can also make use of a GPU to further speed processing time. A GUI based workbench is also provided to help model and train neural networks. Encog has been in active development since 2008."
Encog is available for Java, C#.Net and Silverlight.
http://www.heatonresearch.com/encog
在学校的 nn 课程中，我们使用 matlab，然后我使用 java 来完成我的论文。
我建议java或者matlab。 Matlab 因为它可能已经有很多你可能需要的东西。还有 java，因为它可以快速实现开源项目中可能缺少的功能。除此之外，除了实现神经网络之外，您可能还需要某种方法来可视化它们。为此，我个人认为 java 或 matlab 相当容易。
In my nn classes in school we used matlab and then I used java for my thesis.
I would suggest java or matlab. Matlab because it probably already has alot of what you might need. And java because it is quick to implement what might be missing in open source projects. And besided since besides implementing the neural networks you might need some way to visualize them. And for that I personally believe that java or matlab is quite easy.
我喜欢洪水。它是免费的、全面的，并且用 C++ 编写。
I like flood. It's free, comprehensive, and written in C++.
Matlab 中的实现是复杂且完整的。我发现它足以评估不同类型的网络。它也可以使用外部接口进行编程。
然而，由于算法的实现不是开源的，因此当您需要将特定代码段移动到 Matlab 之外的应用程序中时，有时会更加困难，因为我手工编码的不同神经网络类型的实现会产生不同的结果。
The implementations in Matlab are sophisticated and complete. I have found it to be sufficient for evaluating different types of networks. It is also very programmable using external interfaces.
However, since the implementations of the algorithms are not open source, it is sometimes more difficult when you need to move a particular piece of code into an application outside of Matlab, as my hand coded implementations of different neural network types produced different results.
我已经开始使用 C++ 编写一个 NN 实现，但发现我对开始时涉及的数学了解不够。最终发生的情况是，当我调整计算模型时，重构代码太困难了。
最终我选择了 MATLAB，因为它绝对是学习神经网络工作原理的更好伴侣。我能够使用几个按键对算法进行巨大的更改，并绘制结果。
如果我使用已经构建的矩阵计算框架，也许我的体验会更好。考虑到这就是 3D 的方式，应该有一些针对大多数语言的真正优化的库。哎呀，您不妨利用 Direct3D 或 OpenGL 来实现这一点，但我确信有更适合神经网络的东西。
我想我没有提供太多关于你应该做什么的信息。然而，我可以告诉你不应该做什么——那就是尝试自己编写矩阵操作代码。
I have started writing a NN implementation using C++ and found that I didn't know enough about the maths involved in the beginning. What ended up hapenning was that it was too hard to refactor the code as I was tweaking the calculation model.
Eventually I gave into MATLAB as it was definitely a better companion to learning how neural networks work. I was able to make huge changes to the algorithm using a few key strokes and graph the results too.
Perhaps my experience would have been better if I had used an already built matrix computation framework. Considering that's how you do 3D there should be a few really optimized libraries out there for most languages. Heck you might as well leverage Direct3D or OpenGL for that, but I am sure there is something more suitable for Neural Networks out there.
I guess I am not providing much information on what you should do. I can however tell what you should not do - and that's trying to write matrix manipulation code yourself.
您可能想看看Weka。它有一些用于数据可视化等内置工具，并且已经存在多年了（一些屏幕截图）。
You might want to give Weka a look. It has some built-in tools for things like data visualization, and it's been around for years now (some screenshots).
在我看来，使用神经网络的关键是获得正确的训练集，而不是网络本身如何在代码中实现。我会根据您尝试使用网络解决的问题类型来选择一种语言。对于网络本身来说，c++、c#、python 和 java 都是可行的。
您是否在解决需要图像处理的问题时使用它？在这种情况下，您可能需要能够轻松连接到 OpenCV 等图像处理库的东西。或者是否涉及一些音频处理？
您可能需要轻松地可视化训练集，那么对于所选语言来说这有多容易？您可以直接或使用某种包装器使用 OpenGL 或 DirectX 库吗？对于 DirectX，选择是 C++ 和 C#。更高层次的抽象认为使用 WPF 有效吗？
我使用 C# 是因为我熟悉它，并且可以利用 .net 中的众多数据处理技术，并使用 wpf 进行任何所需的可视化。
In my view in working with neural networks the key is getting the training set right not so much how the network itself is actualised in code. I would choose a language based on the type of problem you are trying to solve using the network. For the network itself c++, c#, python and java are all viable.
Are you using this in connection with a problem requiring image processing? In which case you will probably want something that hooks up to an image processing library like OpenCV easily. Or is there some audio processing involved?
You may need to easily visualise the training sets so how easy would this be with the language of choice? Can you work with either OpenGL or DirectX libraries either directly or using a wrapper of some kind? For DirectX the choices are C++ and C#. Will a higher level of abstraction say using WPF work?
I have used C# because I am familiar with it and can leverage the numerous data handling technologies in .net and use wpf for any visualisations needed.
您可能还想尝试 Nen - 它是免费的，易于使用并且非常轻量。它还在许多流行的回归中在开箱即用的比较中优于 LIBSVM - 和分类数据集。
You might also want to give Nen a try - It's free, easy to use and very lightweight. It also outperforms LIBSVM in an out-of-the-box-comparison on many popular Regression- and Classification-Datasets.
通常，当我修改这些类型的算法时，我发现使用开源 Weka Toolkit 是原型设计和发现一大堆不同学习算法（不仅仅是人工神经网络）的好方法。如今，它们似乎具有来自许多不同语言的绑定，因此如果您想在代码级别与 Weka 交互，您不应该依赖 Java。
一旦我发现并理解了一些很酷的东西/做了相当好的分类工作，我就用 C 或 C++ 编写了算法，部分是为了好玩，部分是为了获得处理更大数据集所需的必要速度增益。
Typically when I was tinkering with these kinds of algorithms, I found that using the open-source Weka Toolkit was a great way to prototype and discover a whole bunch of different learning algorithms (not just artificial neural networks). These days, it looks as though they have bindings from a bunch of different languages, so you shouldn't be tied to Java if you want to interact with Weka at the code level.
Once I found and understood something that was cool/doing a pretty good classification job, I wrote the algorithm in C or C++ partly for fun and partly to gain the necessary speed gains required to work with larger data sets.
使用 C++，如果你的神经网络足够简单，就不要使用奇怪的框架。
大概 5 年前，我使用强化学习做了一个推箱子求解器。当时我们决定使用 Java 并使用意大利大学开发的一些代理框架。
第一个错误的决定是使用这个框架。它基本上到处都有错误，导致我们浪费大量时间来调试框架的代码。
一旦我们达到一切稳定的程度，神经网络的训练就变得非常缓慢。我们让它在一台功能强大的机器上运行了一夜，但它仍然解决了很少的难题。基本上，Java 对象分配和垃圾收集严重损害了系统的整体性能。我们通过创建对象池而不是一直分配它们来对应用程序进行了一些调整，但程序的性能仍然比直接使用套接字在 C++ 中实现的类似分配低一个数量级。
希望这有帮助！
Use C++ and if your neural network is simple enough don't use weird frameworks out there.
Maybe 5 years ago I did a Sokoban solver using Reinforcement Learning. At the time we decided to go with Java and use some Agent Framework developed by an Italian University.
First bad decision here was to use this Framework. It basically had bugs here and there which caused us to waste loads of time debugging the framework's code.
Once we got to the point where everything was stable, training the Neural Network was just dead slow. We left it running overnight in a quite powerful machine and still it solved very few puzzles. Basically Java object allocation and garbage collection were damaging the whole performance of the system quite badly. We tweaked a bit the app by creating pools of objects instead of allocating them all the time but the program's performance was still an order of magnitude less than a similar assignment that was implemented in C++ using sockets directly.
Hope this helps!
好吧，如果您想快速构建原型，那么 python 或 matlab 似乎是最好的。有很多可用于神经网络的库。一些库的设计方式是为您提供最少的调整范围，但像 Theano 这样的库速度非常快，因为该函数是在 C 中内部编译的（我猜是迄今为止最快的），并且它为您提供了内部的完整功能调整。 Theano 最初通常使用，但功能非常强大。稍后，如果你想从神经网络转向深度神经网络，那么就没有太大区别了。专业 Kaggler 也倾向于使用这个库。该库还具有 GPU 支持。在我使用过的所有库中，我发现 theano 是最有用和最强大的。其他一些最先进的深度学习框架（例如 Caffe）是在 theano 上开发的。
希望这有帮助。
Well, if you like to prototype fast then python or matlab seems the best. There are a lot of libraries available for neural networks. Some of the libraries are designed in such a way that they give you minimal amount of tweaking scope but libraries like Theano are extremely fast as the function are internally compiled in C(i guess the fastest till date) and it gives you full functionality of internal tweaking. Theano is typical to use at first but is extremely powerful. And later if you wish to move from neural to deep neural then there is not much of a difference. Professional Kagglers also tend to use this library. This library also has GPU support. Of all the libraries i have used i found theano to be the most useful and powerful. Some of the other state of the art framework for deep learning like Caffe are developed on theano.
Hope this helps.
我已经用 Java 和 C/C++ 实现了几个神经网络原型。当性能很重要时，请与 C/C++ 一起使用。
我的一个基本多层感知器的实现（非矢量化）在不到一分钟的时间内完成了一百万次训练迭代（设置了 2 个输入、4 个隐藏节点和 1 个输出节点）。我在 Java 中几乎相同的实现需要花费大量时间来完成此操作。
您还可以使用 Eigen 等线性代数库来创建矢量化版本以提高处理速度。
想象一下，您将使用它进行任何类型的图像处理（面部识别、OCR 等），例如 28x28 像素图像。您将有 784 个输入单元和至少同样多的隐藏单元。这需要大量的时间进行训练，因此有利于节省宝贵的几分钟、几小时或几天。
I've implemented several neural network prototypes in Java and C/C++. When performance matters, use with C/C++.
One of my implementation (not vectorized) of a basic Multilayer Perceptron does a million training iterations (with a setup of 2 input, 4 hidden and 1 output node) in less than a minute. My almost identical implementation in Java takes a huge amout of time to do this.
You could also use a linear algebra library like Eigen to create a vectorized version to improve the processing speed.
Imagine you would use yours for any kind of image processing (Face-Recognition, OCR, etc.) with, for example, 28x28 pixel images. You would have 784 input units and at least as many hidden units. This takes a huge amount of time to train so it's beneficial to save precious minutes, hours or days.