Introduction to Neural Networks with Java (Paperback)

by Jeff, T Heaton (Author) "Computers can perform many operations considerably faster than a human being..." (more)
Key Phrases: Von Neumann, Control Panel, Input Layer Hidden Layer (more...)

Editorial Reviews

Product Description

Introduction to Neural Networks in Java introduces the Java programmer to the world of Neural Networks and Artificial Intelligence. Neural network architectures such as the feedforward backpropagation, Hopfield, and Kohonen networks are discussed. Additional AI topics, such as Genetic Algorithms and Simulated Annealing, are also introduced.

Practical examples are given for each neural network. Examples include the Traveling Salesman problem, handwriting recognition, fuzzy logic and learning mathematical functions. All Java source code can be downloaded online. In addition to showing the programmer how to construct these neural networks, the book discusses the Java Object Oriented Neural Engine (JOONE). JOONE is a free open source Java neural engine.

About the Author
Jeff Heaton is an author, college instructor, and consultant. Jeff lives in Chesterfield (St. Louis), Missouri. The author of four books and over two dozen journal and magazine articles, Jeff specializes in Internet, socket-level/spidering and Artificial Intelligence programming. A Sun Certified Java Programmer and a Senior IEEE Member Jeff holds a Masters Degree in Information Management from Washington University in St. Louis.

Product Details

• Paperback: 380 pages
• Publisher: Heaton Research, Inc. (November 25, 2005)
• Language: English
• ISBN-10: 097732060X
• ISBN-13: 978-0977320608
• Product Dimensions: 9.2 x 7.4 x 0.9 inches
• Shipping Weight: 1.5 pounds (View shipping rates and policies)
• Average Customer Review: 4.2 out of 5 stars See all reviews (4 customer reviews)
• Amazon.com Sales Rank: #607,324 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #54 in	Books > Computers & Internet > Certification Central > Java
  #54 in	Books > Computers & Internet > Certification Central > Exams > Java
  #88 in	Books > Computers & Internet > Programming > Java > Beginner's Guides

Customer Reviews

Most Helpful Customer Reviews

14 of 14 people found the following review helpful:

5.0 out of 5 stars Excellent practical book on neural networks using Java, March 26, 2006

By	calvinnme "Texan refugee" (Fredericksburg, Va) - See all my reviews (TOP 10 REVIEWER)

Programming Neural Networks in Java will show the intermediate to advanced Java programmer how to create neural networks. This book attempts to teach neural network programming through two mechanisms. First the reader is shown how to create a reusable neural network package that could be used in any Java program. Second, this reusable neural network package is applied to several real world problems that are commonly faced by programmers. This book covers such topics as Kohonen neural networks, multi layer neural networks, training, back propagation, and many other topics. The content of the book is as follows:
Chapter 1: An Introduction to Neural Networks
The structure of neural networks will be briefly introduced in this chapter. Also discussed is the history of neural networks, since it is important to know where neural networks came from, as well as where they are ultimately headed. Finally, there is a broad overview of both the biological and historic context of neural networks.
Chapter 2: Understanding Neural Networks
A neural network can be trained to recognize specific patterns in data. This chapter will teach you the basic layout of a neural network and end by demonstrating the Hopfield neural network, which is one of the simplest forms of neural network.
Chapter 3: Using Multilayer Neural Networks
You will see how to use the feed-forward multilayer neural network and two ways that you can implement such a neural network. The chapter begins by examining an open source neural network engine called JOONE. JOONE contains a neural network editor that allows you to quickly model and test neural networks.
Chapter 4: How a machine learns
Every learning algorithm involves somehow modifying the weight matrices between the neurons. This chapter examines some of the more popular ways of adjusting these weights.
Chapter 5: Understanding Back Propagation
This chapter examines one of the most common neural network architectures-- the feed foreword back propagation neural network.
Chapter 6: Understanding the Kohonen Neural Network
The Kohonen neural network contains no hidden layer. The Kohonen neural network differs from the feedfroward back propagation neural network in several important ways. This chapter examines the Kohonen neural network and how it is implemented.
Chapter 7: Optical Character Recognition
This chapter develops an example program that can be trained to recognize human handwriting. It is not a program that can scan pages of text. Rather this program will read character by character, as the user draws them. This function will be similar to the handwriting recognition used by many PDA's.
Chapter 8: Understanding Genetic Algorithms
A chapter on an AI technology unrelated to neural networks.
Chapter 9: Understanding Simulated Annealing
A second AI technology that can be used to train neural networks.
Chapter 10: Eluding Local Minima
One of the most fundamental flaws is the tendency for the backpropagation training algorithm to fall into a "local minima". A local minimum is a false optimal weight matrix that prevents the backpropagation training algorithm from seeing the true solution. This chapter shows how to use certain training techniques to supplement backpropagation and elude local minima.
Chapter 11: Pruning Neural Networks
This chapter examines several algorithms that modify the structure of the neural network. This structural modification will not generally improve the performance of the neural network, but makes it more efficient. If a particular neuron's connection to other neurons does not significantly affect the output of the neural network, the connection will be pruned.
Chapter 12: Fuzzy Logic
Fuzzy logic is a branch of AI not directly related to the neural networks examined so far. Fuzzy logic is often used to process data before it is fed to a neural network, or to process the outputs from the neural network. Fuzzy logic is examined in reference to removing SPAM from emails.
Appendix A: JOONE Reference
Appendix B: Mathematical Backgrounder
Appendix C: Using the Examples on a Windows System
Appendix D: Using the Examples on a UNIX System
This book is currently available online. Since Amazon throws out reviews with web addresses in them, suffice it to say that you just need to type "HeatonResearch" into Google. The 2nd address is the one you want. This book couples accessible instruction with plenty of code that you can lift to make your own neural network applications. I highly recommend it.

10 of 10 people found the following review helpful:

5.0 out of 5 stars Unique book, January 30, 2006

By	Carlos F. S. Antunes "Scheidecker" (Scheidecker) - See all my reviews (REAL NAME)

I have received my copy of the book and I can't put it down. It has been great help with my AI research at the University. I have the other book from the same author "Programming Spiders, Bots and Aggregators in Java" and I have the same comments for both. Both are easy to read, have precise information and great code. Chapter 7 of this book "OCR with Kohonen Neural Network" makes the book more than worth it. Great stuff. I hope the author does not stop and keep writting books like these. I recommend this book for anyone interested in learning AI and also experienced programmers alike. The author makes though topics seem easy. Highly recommended.

14 of 20 people found the following review helpful:

3.0 out of 5 stars A bit disappointed because I expected more from this book., June 19, 2006

By	Starkfuji - See all my reviews

I have been reading through the book. Actually it provides very clear explanations, but I had the impression the author talks too much and keep saying the same things over and over again. The book could be half its volume with the same content of knowledge. Besides the provided examples are a bit too simple and obvious.
Nothing much to put under the tooth. After reading it I felt left with my hunger for something deeper and more consistent. The algorithms provided also merely implement and stick to the few examples introduced. On the course of the book, the author wanders from the main point which is first and foremost to discuss neural networks under all angles. He unexpectedly brings up Fuzzy logic and Genetic algorithms which is not what the book title purports to talk about: a bit of confusion.
Overall there is a bit of deception, but indeed the book does what its title says : it is really just an "introduction" to Neural Networks with Java and nothing more. I would recommend it to somebody seeking to embrace the field and who is really a beginner in the domain.