Hands-On Artificial Intelligence with Java for Beginners
Build intelligent apps using machine learning and deep learning with Deeplearning4j
Nisheeth Joshi
- 144 pagine
- English
- ePUB (disponibile sull'app)
- Disponibile su iOS e Android
Hands-On Artificial Intelligence with Java for Beginners
Build intelligent apps using machine learning and deep learning with Deeplearning4j
Nisheeth Joshi
Informazioni sul libro
Build, train, and deploy intelligent applications using Java libraries
Key Features
- Leverage the power of Java libraries to build smart applications
- Build and train deep learning models for implementing artificial intelligence
- Learn various algorithms to automate complex tasks
Book Description
Artificial intelligence (AI) is increasingly in demand as well as relevant in the modern world, where everything is driven by technology and data. AI can be used for automating systems or processes to carry out complex tasks and functions in order to achieve optimal performance and productivity.
Hands-On Artificial Intelligence with Java for Beginners begins by introducing you to AI concepts and algorithms. You will learn about various Java-based libraries and frameworks that can be used in implementing AI to build smart applications.
In addition to this, the book teaches you how to implement easy to complex AI tasks, such as genetic programming, heuristic searches, reinforcement learning, neural networks, and segmentation, all with a practical approach.
By the end of this book, you will not only have a solid grasp of AI concepts, but you'll also be able to build your own smart applications for multiple domains.
What you will learn
- Leverage different Java packages and tools such as Weka, RapidMiner, and Deeplearning4j, among others
- Build machine learning models using supervised and unsupervised machine learning techniques
- Implement different deep learning algorithms in Deeplearning4j and build applications based on them
- Study the basics of heuristic searching and genetic programming
- Differentiate between syntactic and semantic similarity among texts
- Perform sentiment analysis for effective decision making with LingPipe
Who this book is for
Hands-On Artificial Intelligence with Java for Beginners is for Java developers who want to learn the fundamentals of artificial intelligence and extend their programming knowledge to build smarter applications.
Domande frequenti
Informazioni
Exploring Search Algorithms
- An introduction to searching
- Implementing Dijkstra's search
- Understanding the notion of heuristics
- A brief introduction to the A* algorithm
- Implementing an A* algorithm
An introduction to searching
- S: A set of implicitly given states—all of the states that might be explored in a search process.
- s: The start symbol—the starting point of the search.
- O: The state transition operators, which indicate how a search should proceed from one node to the next and what transitions are available to the search. This is an exhaustive list. Therefore, the state transition operator keeps track of these exhaustive lists.
- G: The goal node, pointing to where the search should end.
- The minimum cost transaction for a goal state
- A sequence of transitions to a minimum cost goal
- A minimum cost transaction for a minimum cost goal
- Initialize: Set OPEN = {s},
- Fail: If OPEN = {}, Terminate with Failure
- Select: Select the minimum cost state, n, form OPEN, and Save n in CLOSE
- Terminate: If n ∈ G, Terminate with Success
- Expand: Generate the successors of n using 0
- Loop: Go to Step 2
- Initialize: We initialize the algorithm and create a data structure called OPEN. We put our start state, s, into this data structure, and create one more data structure, CLOSE, which is empty. All of the states that we'll be exploring will be taken from OPEN and put into CLOSE. We set the cost of the initial start state to 0. This will calculate the cost incurred when traveling from the start state to the current state. The cost of traveling from the start state to the start state is 0; that's why we have set it to 0.
- Fail: In this step, if OPEN is empty, we will terminate with a failure. However, our OPEN is not empty, because we have s in our start state. Therefore, we will not terminate with a failure.
- Select state: Here, we will select the minimum cost successor, n, and we'll take it from OPEN and save it in CLOSE.
- Terminate: In this step, we'll check whether n belongs to the G. If yes, we'll terminate with a success.
- Expand: If our n does not belong to G, then we need to expand G by using our state transition operator, as follows:
- If it is a new node, m, and we have not explored it, it means that it is not available in either OPEN or CLOSE, and we'll simply calculate the cost of the new successor (m) by calculating the cost of its predecessor plus the cost of traveling from n to m, and we'll put the value into OPEN
- If it is a part of both OPEN and CLOSE, we'll check which one is the minimum cost—the current cost or the previous cost (the actual cost that we had in the previous iteration)—and we'll keep that cost
- If our m gets decreased and it belongs to CLOSE, then we will bring it back to OPEN
- Loop: We will keep on doing this until our OPEN is not empty, or until our m does not belong to G.
- n(S) is the number of states/nodes
- s is the start node
- G is the goal node
Indice dei contenuti
- Title Page
- Copyright and Credits
- Packt Upsell
- Contributors
- Preface
- Introduction to Artificial Intelligence and Java
- Exploring Search Algorithms
- AI Games and the Rule-Based System
- Interfacing with Weka
- Handling Attributes
- Supervised Learning
- Semi-Supervised and Unsupervised Learning
- Other Books You May Enjoy