Customer Reviews

Object-Oriented Neural Networks in C++

5 star:		(6)
4 star:		(9)
3 star:		(3)
2 star:		(2)
1 star:		(1)

 

 

This book is an excellent book for people with little or no background in Neural Networks. The description and name of the book is pretty much what you'll get. The book begins by giving a background in C++, from there they build the basic objects and theory needed for neural nets in general. Then Rogers proceeds to give a quick overview of each of the four neural nets that he covers in the book, in terms of mathematical definitions of those networks. Then the next chapters are dedicated to his implementation of each one of those four networks (Adaline, Backpropagation, Self-Organizing, & Binary Access Memory), including examples of how each one could be used.

If you are looking on a book that goes into a large variety of neural networks, or that goes into the in-depth theory behind neural networks, then this might not be the book that you are looking for. Although Rogers gives a sufficient background and a firm basis of neural nets and C++ (you shouldn't get lost in the reading), his main purpose in the book is the actual programming implementation. The books main function (in my view), is to provide the reader with the tools on how to actually approach PROGRAMMING neural networks.

My only complaint for this book was the extent of the examples that Rogers provided. The examples were limited in scope (and he mentions this) and detail. It would have been a little more helpful if more "application" information had been given; instead of just "programming" information. Still, though, the book is worth it if you want a strong basis on coding a neural network.

All in all a great book, if you take into consideration the book's purpose. Rogers has a clean and clear writing style. He provides enough fundamental information throughout the book in terms of programming background and neural network background before proceeding to give the "meat" of the book.

Christopher Sean Morrison

Unlike many books on similar topics, Object-Oriented Neural-Networks in C++ provides a truly object-oriented approach to the design and implementation of neural networks. This book is not only a good tool for those beginning with neural-networks giving step-by-step instructions for constructing a variety of neural network architectures, it also provides a good set of tools for the advanced neural network user to build more flexible and powerful neural-network architectures. The book covers 4 basic neural network architectures (ADALINE, Backpropagation, Self-Organizing, and BAM); however, the object foundation provided by the book can be the basis for any neural network architecture. The book contains a complete set of source code (in print and on disk) for all objects described, real-world examples, and a review of the C++ programming techniques used throughout the book

If you're trying to learn neural nets, this book gives you a fairly decent overview of four different types. It doesn't go into much depth, but it's easy for a beginner to pick up. If you're trying learn object-oriented programming and/or c++, _don't_buy_this_book_. The code is buggy, bloated, poorly designed, inefficient and just plain bad. To list some of the problems I encountered with it:

___________________________________________________________________________________________________________________________________________________________________________________________________ 1) The Base_Link::Save function corrupts object and writes corrupted data to a file. 2) No const, *anywhere*. 3) Repeatedly attempts to inline virtual functions. Virtual functions *can't* be inlined because they aren't evaluated until runtime. 4) Most function implementations placed in header files. Maybe due to the use of those magical "inline virtual" functions. 5) Never uses STL containers even where they would be optimal. Creates arrays with new where std::vector would work better, and defines custom linked-list class (very ugly). 6) Uses ofstream/ifstream where ostream/istream would be preferable. The whole point of c++ streams is to have a single set of interfaces for handling io from any origin. Using the fstreams just creates an unnecessary restriction. 7) Creates an array in base class interfaces for use by subclasses as a variable container, as opposed to just creating variables in the subclasses. In my opinion, this is his most egregious offense. It defeats the whole purpose of inheritance. 8) Use of static data in classes. Don't bother using this code in a multithreaded app. Neural nets are usually well suited for multithreading, but certainly not this implementation. 9) Non-virtual destructor in interface classes. Doesn't matter in this case, because he stored all implementation-specific data in the interface class, but is generally poor practice because it can lead to memory leaks. 10) Too few comments that aren't completely redundant, for example: "Base_Link(); // Constructor" 11) The classes are unnecessarily general. Just about every function is virtual, even ones that should never be overridden. The inheritance heirarchy of his objects also suggests that nodes and links can vary implementation within a single network, but never do. In fact, link, node, and neural-network (link/node container) objects all make explicit assumptions about each others' implementations. The examples will crash if you try to use objects of varying implementations together. 12) There are functions in the interface classes that vary *usage* depending on implementation. This means you cannot use them without knowing the exact implementation you are dealing with. The whole point of virtual functions is to provide a single function with a consistent usage even though the implementation may vary. ___________________________________________________________________________________________________________________________________________________________________________________________________ To sum up, if you want a simple overview of a few neural network types and love a fixer-upper, this is the book for you. Otherwise don't bother.

This book is really good for the any person who is interested in neural networks. The author describes the four types of neural networks and shows how they are implemented in C++. Also, he presents a practical use for each type of network. Even though he uses C++ code to implement the neural nets, I believe that only a general knowledge of C/C++ is necessary to understand the implementation. The author leaves out some of the more advanced material. He DOES NOT go into too much detail about all (or most) of the uses of each neural net -- he only presents a limited number of applications. He does not abstract into how each network can be adapted for other purposes. All in all, I believe that this is an excellent book that will show you simple neural net applications and explain how they are implemented using C++.

It may suprise some people to learn that not all programmers are experts at higher math. I had gone through dozens of web sites and several books looking for a way to implement a neural network. All of these sites talked about network theory and analysis with lots of greek letters that meant nothing to me but none of them had any code. This book lays out object oriented code for four of the most common types of neural networks and explains every property and function in detail. If you are looking for a book on neural network theory this is not it. If you are looking for code samples that let you build basic networks and play with them yourself this book is perfect.

This book does give a good introduction to programming neural networks in C++. The author has a good grasp of object oriented design and he shows how to exploit this in the construction of certain kinds of neural networks. The code in the book is flexable and fairly well laid out. I was able to port it to Java with relatively few alterations.

I would recommend this book to anyone interested in starting to program neural nets. It probably requires a little background in C++, but the primer in the beginning of the book actually taught me something (I read this book a year ago when I was fairly new to OOP)!

I use the source code from this book for a two weeks practical course in
neural networks for biology students. There is much to criticize about C++
style, OO-design, and even about the implementation of some networks (In the
backpropagation algorithm corrections to the weights should be made only after
the backpropagated error has been computed for all units in the
network).

However, I think it is great to have some reasonably well documented code to
play with. Within a day or so the students manage to run the first networks
without being C++ experts. In my view, it is extremely instructive to have
some source code, even if it is not the best. A nasty fact, though, is that
the code does not compile from the scratch (I have a little perl script that
replaces some errors in the sources, such that the code complies nicely using
g++ under Linux: look for it on my webpages under the
topic "teaching"; I don't give the address here, because it might change).

Summarizing, I like the book for what it is, an example of OO implemented
neural networks. I would not use the code for a "real" project nor expect to
learn from the book why networks work the way they do.

Neural networks are pervasive in the modern business and research environment. The applications of neural networks are enormous and include fields such as financial engineering, network modeling, computational radiology, medicine, and brain modeling.

For readers who know C++, this book gives a thorough overview of neural networks from the standpoint of the source code used to represent them. It is expected that the reader has had some exposure to neural networks, for no detailed discussion is given of their history or properties. The author attempts to stick to a purely object-oriented framework, and refrains from giving what he calls a "coarse-grained" approach to an object-oriented implementation of neural networks. The later according to him is merely a collection of C++ wrappers around existing C code. The base objects are the nodes and links of the neural networks, called the Base-Node and Base-Link classes in the book. The author admits this approach degrades performance, but design and development of complicated neural net architectures is enhanced, he argues.

After a brief review of object-oriented programming in chapter 2, the author treats the neural network base classes in chapter 3. He defines a neural net as a 3-tuple consisting of a pattern set, parameters, and topology. The ADALINE, backpropagation, Kohonen self-organizing, and BAM neural-network architectures are treated throughout the book in chapters 4, 5, 6, and 7 respectively. The XOR problem is discussed as an example of learning with a backpropagation neural network, along with an example from lithology. Also, for those readers who are using compilers that do not support template classes, the author creates a generic backpropagation neural-network class. This class is constructed to make the creation of a back-propagation class more transparent.

The only major problem with the book is the lack of examples illusrating the Kohonen and BAM neural networks and the lack of in-depth discussion of neural networks. For readers very familiar with neural networks and C++, this book should work well.

I bought this book under the idea that it was a beginners book that would teach me neural network concepts, and then it would cover the proper way to implement them in an object oriented enviroment. When I read this book I got something completely different...

In this book, the author covers in great detail his implementation of 4 neural network topographies. He takes great care in explaining his choices in object oriented design, and reasons he chose to subclass things certain ways, etc.. etc.. I feel like the title of this book should have been: "Object Oriented Programming, a case study in Neural Networks."

After reading this book I did not have the tools to even slightly modify any of his neural network topographies, I did not really have to tools to explain why certain topographies would be advantageous over others in certain situations. What I did know however was how Joey Rogers had programmed 4 neural networks, and how he belived Object Oriented Programming should be practied. If you are interested in learning Neural Networks, a bit of theory, or even why you would use them, this book is certainly NOT for you.

I've always wanted to learn about neural network programming, but have been disappointed with the books on the subject in the past. This book presents the reader with a complete object-oriented approach to neural network programming, and provides a basis upon which any new neural network design may be based.

The example programs are short and easy to follow, and the entire source code for the class libraries are listed in the back of the book for reference (and also included on the disk).

What I'm most fascinated with is image and pattern recognition, and this is the path I plan to take with this library. It is certainly robust enough to handle any neural network concept, and extensible. The source code was written with straight ANSI C++ (or standard template library, as I recall), so it is portable to almost any platform.