Customer Reviews

C++ Neural Networks and Fuzzy Logic

5 star:		(5)
4 star:		(2)
3 star:		(1)
2 star:		(3)
1 star:		(14)

 

 

To say this book is confusing is an understatement. I am a veteran C++ programmer, with a background in financial application development, looking to expand my skill set. I found this book to be a waste of money.

The chapter on object oriented (OO) programming should have been a warning to me. I remember reading it and thinking, "It's a good thing I'm already familiar with OO, because I would never be able to figure it out from this chapter". I'm not terribly familiar with Neural Networks or Fuzzy Logic and, after reading the first four chapters, I am even more confused than when I started. I think that each topic is getting the same poor treatment that the OO chapter received.

The explanations in this book are useless. Here is an excerpt about how to figure out how many patterns a four node Hopfield network may recall (by the way, the reader is never told what a Hopfield Network is, but is left to infer the key characteristics of a Hopfield Network by comparing the given example to a previous example - which was apparently not a Hopfield network).

"If a pattern P has k, less than 4, bit positions with 0 (and so 4-k bit positions with 1), and if pattern Q is to be orthogonal to P, then Q can have 0 or 1 in those k positions, but it must have only 0 in the rest 4-k positions. Since there are two choices for each of the k positions, there are 2[to the kth power] possible patterns orthogonal to P. this number 2[to the kth power] of patterns includes the pattern with all zeroes. So there really are 2[to the kth power]-1 non-zero patterns orthogonal to P. Some of these 2[to the kth power]-1 patterns are not orthogonal to each other. As an example, P can be the pattern 0 1 0 0, which has k = 3 positions with 0. There are 2[to the 3rd power]-1=7 non-zero patterns orthogonal to 0 1 0 0. Among these are patterns 1 0 1 0 and 1 0 0 1, which are not orthogonal to each other, since their dot product is 1 and not 0." Pg 64

Surely there is a better, and more understandable, way to explain this concept (and every other concept in this book).

I get the feeling that the authors are just going through the motions. They must have created an outline of topics that should be included in a book entitled C++ Neural Networks & Fuzzy Logic but spent little time populating each topic with meaningful information. There seems to be just enough information under each heading to enable someone who already knows the subject to say, "yes that is correct".

This book is a mess.

I'm sorry, this book is nearly useless. I'm a vetern C++ programmer and I tried to create a fuzzy logic system from the concepts and code in this book and it didn't work out at all. At first I blamed myself then I found some other fuzzy logic books and realized that no, this book just wasn't able to articulate the concepts in a meaningful way. The Neural net code was even worse. I wanted a cook book, do this, get a simple net, do this get a simple fuzzy logic system, now take what you learned and make a real one. Nope.

They do go over the AI terms and types of Neural nets and I did learn something by reading about it but not enough to justify the price of the book.

Being a professional C++ programmer with a background in Applied Math I didn't like this book at all. It's written in a very annoying way: sometimes it sounds like its author is trying to sell the whole concept of NN and Fuzzy Logic to the reader instead of explaining how, when, and WHY fuzzy logic and neural networks work, how to train them properly, and what their limitations are. One characteristic example: author presents a list of companies using fuzzy logic in real systems but never gives any useful details about these systems.

The book is not for a "mathematician" since it often lacks precision, coherence, mathematical rigor, clarity, ... More often than not, you will find wordy explanations instead of simple formulas

It will displease a "programmer" too. The book's title is "C++ Neural Networks and Fuzzy Logic" so one may expect to find some well-thought and proven design ideas on how to implement NN and FL in C++ as well as a decent C++ library. Instead you will find just an amateurish C++ code (like anybody had any doubts that NN can actually be implemented in C++).

Numerous times author uses this "trick": he introduces new concept, delivers a couple of vague statements about the concept, and promises a better explanation later (in the following chapters, next series, etc).

How do you like this for definition: "STABILITY refers to such convergence that facilitates an end to the iterative process". You can find a lot of such "pearls" in this book.

Don't waste your time... There are better books

FYI: the book includes just a floppy disk instead of CD.

As a previous review mentioned, I found myself re-reading paragraphs several times, but this was required in many cases just to understand what the authors were trying to say. This is a very shallow and, in some cases, misinformed and glossy survey of the subject.

I have struggled my way to the end of chapter 4, and am debating wether or not it is worth finishing. Near the end of this chapter is an example of a NNet trained to play TicTacToe. The network is presented as an adaptive net that actually changes its architecture as it learns. The authors expend a fairly large area explaining the rules of TicTacToe, but NEVER describe the rules that the network uses to adapt! It seems to me that the authors do not understand the material they are trying to present. Even more frustrating is that, although the author of this network is given, the source of the original work is not found in the references!

!!!DO NOT BUY THIS BOOK!!!

I was very dissappointed with this book. I liked the idea of having the theory of neural networks and fuzzy logic with examples in C++ code. Unfortunately, the book is poorly written. The theory behind neural networks and fuzzy logic is not explained well with quite a bit of unexplained jargin. The C++ code is usable but not well done. I felt that the C++ code should be secondary to the explanations anyway, but it would have been nice to see good code. I recommend against getting this book.

The only good thing about this book is it glossy cover page. It should rank amongst the most poorly written technical books ever! I can safely say that neither a beginner or an expert in the topic would be able to follow this book . It does sound like the authors spent very little time in trying to attempt making the concepts clear. instead what we really see here is a hurried collection of extracts from all the bibliographic references. The Authors should go for a complete re-write of this book if they are planning a third edition and focus on making it much more clearer and understandable. for now....just avoid this book!

At first this book promises to offer a great deal for the reader, and the copious amounts of code therein support this impression. But once one actually begins working with the text, the book's shortcomings become all too apparent.

The authors do a lot of 'hand waving' at important concepts, almost as though the book was written as a companion piece to a course lecture. (Sometimes it really does read as though it's just a transcribed volume of professor's notes.) Numerous times I found myself stopping and thinking "wait, don't get off that topic yet! You've barely addressed its basics," and wondering if I had somehow missed something on the previous page or two.

The code supplied is abominably written, a Frankenstein hodgepodge of C and C++ intertwined. This code can be made to run with some work, but it could hardly be used as a sound basis for further development or experimentation.

You can derive good conceptual information out of this book, but it takes a lot of work. You really have to bludgeon your way through it, and that is no recipe for a successful educational text.

This has to be one of the worst books that I've come across. Not only is it poorly written, its totally disorganized. The authors MAKE it a point to extravagantly use terminology without so much as even defining it. The C++ code samples barely fall into the category of C++, one can learn how NOT to write C++ code. I for one will not be rushing to the book stores to buy other books by these authors.

I am greatly discouraged by the poor quality of the editing of the second edition of this book. Entire chapters are misplaced. The mathematics behind the implementation is poorly developed.

Poorly written. Actually not written at all. It's merely a collection of C++ programs with an introductory comment to each program. After typing in the programs you'll realize you still don't know anything behind the theory of either fuzzy logic or neural networks.

The title of this book leads you to believe it covers at least a tiny amount of theory. Just pull some neural networks off the net and analyze those, or buy a book on NN theory. And forget about the fuzzy logic in this book! It only covers a tiny bit on fuzzy set theory, and leaves you without enough understanding to apply fuzzy logic to any problem (including the 'toy' inverted pendulum problem).

DO NOT BUY THIS BOOK! I found it so useless that i ended up throwing it out.