\nPart VI - Hybrid Symbolic and Deep Learning Approaches to Artificial Intelligence

TBD- hybrid AI

",{"_384":385,"_43":44,"_47":48,"_45":46,"_65":66,"_386":387,"_467":382},"previewContent","

\n Cover Material, Copyright, and License\n
- \n This book is licensed with Creative Commons Attribution CC BY Version 3 That Allows Reuse In Derived Works\n
\n
\n Preface\n
- \n Programming Examples in this Book\n
- \n Working with the examples\n
- \n A Request from the Author\n
- \n Credits\n
\n
\n Part I - A Brief Introduction to AI and Effectively Using Python\n
\n An Introduction to Artificial Intelligence\n
- \n Overview\n
- \n An Overview of How the Human Brain Works\n
- \n Introduction to Artificial Neural Networks\n
- \n Symbolic Representation of Facts and Rules (Expert Systems)\n
- \n Symbolic Models for Natural Language Processing\n
- \n Using Deep Learning for Natural Language Processing\n
- \n An Overview of Linguistics\n
- \n The Public’s Perception of Artificial Intelligence\n
\n
\n Python Tips and Techniques\n
\n Ethics and Human Values\n
\n Part II - Machine Learning and Deep Learning\n
\n (Almost) Everything You Really Need To Know About Machine Learning\n
- \n Introduction to Supervised and Unsupervised Learning\n
- \n Feature Engineering\n
\n
\n Tensoflow and Keras Model for Wisconsin Cancer Data Set\n
- \n Jupyter Notebook\n
\n
\n Using TensorFlow for Implementing Deep Neural Networks\n
- \n Installing TensorFlow and Keras\n
- \n Processing Cancer Data With a BackPropagation Network\n
- \n Deep Learning Wrap Up\n
\n
\n Generating Images With Deep Learning\n
\n Part III - Natural Language Processing\n
\n Introduction to Natural Language Processing\n
- \n Exploring the spaCy Library\n
- \n Implementing a HyNLP Wrapper for the Python spaCy Library\n
- \n Coreference (Anaphora Resolution)\n
- \n Wrap-up\n
\n
\n Entity Detection\n
\n Text Generation\n
\n Part IV - Knowledge Representation Using Semantic Web Technologies\n
\n Knowledge Representation Using the Neo4J Graph Database\n
\n Linked Data and the Semantic Web\n
- \n Understanding the Resource Description Framework (RDF)\n
- \n Resource Namespaces Provided in rdflib\n
- \n Understanding the SPARQL Query Language\n
- \n Using the Python rdflib Library\n
\n
\n Knowledge Graph Creator\n
- \n Recommended Industrial Use of Knowledge Graphs\n
- \n Design of KGCreator Application\n
- \n Problems with using Literal Values in RDF\n
- \n Revisiting This Example Using URIs Instead of Literal Values\n
- \n Wrap-up\n
\n
\n Knowledge Graph Navigator\n
- \n Review of NLP Utilities Used in Application\n
- \n Developing Low-Level Caching SPARQL Utilities\n
- \n Utilities to Colorize SPARQL and Generated Output\n
- \n Text Utilities for Queries and Results\n
- \n Finishing the Main Function for KGN\n
- \n Wrap-up\n
\n
\n DBPedia Question Answering System Using SparQL and Deep Learning\n
\n Part V - GOFAI - Good Old Fashioned Symbolic Artificial Intelligence\n
\n Part VI - Hybrid Symbolic and Deep Learning Approaches to Artificial Intelligence\n
\n Part VII - Miscellaneous Code and Techniques\n
\n Using the Microsoft Bing Search APIs\n
- \n Getting an Access Key for Microsoft Bing Search APIs\n
- \n Example Search Script\n
- \n Wrap-up\n
\n
\n Responsible Web Scraping\n
- \n Using the Python BeautifulSoup Library in the Hy Language\n
- \n Getting HTML Links from the DemocracyNow.org News Web Site\n
- \n Getting Summaries of Front Page from the NPR.org News Web Site\n
\n
\n Displaying Graph Data Using PyGraphViz\n
\n Introduction to Programming Quantum Computing\n
- \n Resources\n
- \n The Math You Will Need to Know\n
- \n A Quick Tour of Quantum Information Theory\n
- \n Avalaible Software Simulators and Tools\n
- \n Hy Language Examples\n
\n
\n Book Wrap Up\n
- \n My Other Books That Might Interest You\n
\n

\nCover Material, Copyright, and License

\n\n

\nThis book is licensed with Creative Commons Attribution CC BY Version 3 That Allows Reuse In Derived Works

\n\n

You are free to:

\n\n

Share - copy and redistribute the material in any medium or format.
Adapt - remix, transform, and build upon the material\nfor any purpose, even commercially.

\n\n

You are required to give appropriate credit in any derived works:

\n\n

1 This work is derived from all or part of \"Practical Artificial Intelligence Programm\\\n2 ing in Python\" by Mark Watson.\n3 Source: https://leanpub.com/python-ai\n

\n\n\n\n

This eBook will be updated occasionally so please periodically check the leanpub.com web page for this book for updates.

\n\n

Please visit the author’s website.

\n\n\n

\nPreface

\n\n

I have earned my living as an artificial intelligence practitioner since 1982 using the Common Lisp and Python languages. I cover Common Lisp in another book Loving Common Lisp, or the Savvy Programmer’s Secret Weapon that overlaps some of the main themes in this book. This book is meant to broadly cover techniques for using Python for a wide range of artificial intelligence applications.

\n\n

Professionally, I have used Python for data manipulation for a Knowledge Graph while working at Google, various deep learning consulting jobs, managing a deep learning team at Capital One, and writing recommendation systems at Baby List.

\n\n

I hope you find this book both interesting and deeply practical.

\n\n

You might want to visit my website https://markwatson.com.

\n\n

\nProgramming Examples in this Book

\n\n

\nWorking with the examples

\n\n

I prefer using the Miniconda Python package manager. If you prefer other Python package managers like pyenv or poetry you should have no problems with the book examples since each book project has a requirements.txt file listing dependencies.

\n\n

Some of the examples use third party services like OpenAI’s GPT-3 APIs but for these example projects I take care to show sufficient output for you to understand the examples even if you don’t sign up for the free services I use in the use examples.

\n\n

I have set up the deep learning examples in this book using Google’s Colaboratory that supports Python Jupyter notebooks and provides free access to GPUs and TPUs for training deep learning models.

\n\n

\nA Request from the Author

\n\n

I spent time writing this book to help you, dear reader. I release this book under the Creative Commons license and set the minimum purchase price to $6.00 in order to reach the most readers. Under this license you can share a PDF version of this book with your friends and coworkers. You can also reuse the material in this book for any purpose (including commercial use) with attribution to the author. If you found this book on the web (or it was given to you) and if it provides value to you then please consider doing one of the following to support my future writing efforts and also to support future updates to this book:

\n\n

Purchase a copy of this book at https://leanpub.com/python-ai\n
Buy one of my other eBooks available at https://leanpub.com/mark-watson\n
Hire me as a consultant

\n\n

I enjoy writing and your support helps me write new editions and updates for my books and to develop new book projects. Thank you!

\n\n

\nCredits

\n\n

I would like to thank the following people for their help:

\n\n

Carol Watson: structural and copy editing.

\n\n\n

\nPart I - A Brief Introduction to AI and Effectively Using Python

\n\n

TBD

\n\n\n

\nAn Introduction to Artificial Intelligence

\n\n

I don’t believe that we can talk about AI in a meaningful way without addressing our own human cognition. Since this is primarily a programming book on how to write AI systems, the material in this chapter can be skipped or read later if you want to move on to the cookbook material. Here, I want to here provide some non-programming background material that I hope you find interesting.

\n\n

The word cognitive refers to thinking. When we talk about cognitive computing we intend to understand how we can model the human brain in sufficient detail to write programs that simulate processing input into an internal representation and generate output. In later chapters we will start with training simple feed forward neural network classification models. When we speak of learning a model we mean the process of learning a set of parameters that map input patterns to desired outputs, that is, to be able to make predictions given data similar to the data used to train a model. In the case of neural networks, the parameters of the numeric values of the connection weights in the neural network. Modern neural network architectures mimic the human brain closely enough to make studying human cognition a practical addition to the math and software implementation techniques for simulated neural networks.

\n\n

There are two extremes to modeling the human brain: abstracting away the biological details of the brain, like how neurons fire, with the goal of solving practical problems, or, create detailed (and computationally expensive) low level biological models. We will use the first approach. That said, we want to understand how our brains work, largely because it is intellectually stimulating to understand how we can quickly learn new things, process episodic data and keep it in isolation in the hippocampus, chain together deductions, etc.

\n\n

\nOverview

\n\n

Here are most interested in practical applications of AI technology. I hope that working through this book will have a positive effect on your career.

\n\n

We will look briefly at how the human brain works and then list the practical engineering techniques developed in the field of AI.

\n\n

\nAn Overview of How the Human Brain Works

\n\n

In the following subsections we will look at neural network models of memory: artificial and biological neural networks.

\n\n

The following figure shows a representation of human neurons:

\n\n\n

We will use this figure to discuss a model for biologic neurons collecting activation, spiking, and firing. When a neuron fires it sends a signal outwards through a synapse that in turn connects to the inputs (dendrites) of other neurons. Dendrites branch out from a neuron, like branches on a tree to collect the output from other neurons when they fire.

\n\n

Inputs to neurons usually carry a positive (excitatory) signal but they may also carry a negative (inhibitory) signal. Later when we look at artificial neural networks, these types of connections will be called positive and negative weights. Neurons also get small input from leaking from nearby tissue. Later when we use artificial neural networks, this leakage signal will be called a “bias” input.

\n\n

This process of activiation energy flowing through a real (human or animal) neural network is largely “feed forward” in one direction and performs pattern matching, memory storage, and reactive control. The human brain can also retain episodic memories: sequences of events. The hippocampus is largely responsible for these time sequenced memories. Later when we look at artificial neural networks, we will sometimes use feedback loops that can remember sequences in addition to patterns that a feed forward network can remember. Artificial neural networks with feedback loops are called recurrent neural networks that mimic processes in our brains. Current state of the art practice uses Long Short Term Memory (LSTM) which is a type of recurrent neural network that is capable of recognizing time sequenced patterns that are separted in time. The Tensorflow library has support for experimenting with LSTM. An anology that I like is recognition of a recurring theme when listening to a symphony. The hippocampus provides neural loops that learn specific patterns and can recognize these patterns in the future.

\n\n

The chemical processes in a human brain are fairly well understood and certainly much more complicated than the relatively simple models for artificial neurons and the connections between them, but I find it reassuring that these simple artificial neural network models that are so effective for solving engineering problems are also similar in spirit to how our brains work.

\n\n

Have you wondered how your brain can do such a good job at pattern recognition? We can recognize people in different clothing or hair styles after years of not seeing them and so on. This flexibility is possible because neurons and the connections between them in the neocortex form hierarchical memory structures. At the top of these hierarchical clusters, closest to input signals, collections of neurons with their interconnections learn to recognize fine grained features, like shape of elements of face (nose, eyes, mouth, etc.), hair color, beards and mustaches, and eye color. As we proceed down this hierarchy, neural clusters recognize increasingly abstract patterns; for example, is the person in front of us a man or woman. The main point here is that the memory structures in our brain that provide this flexibility are both distributed and hierarchical. Another key feature of our brains is that neuron activation tends to be sparse; that is, relatively few neurons are firing in response to vision, hearing, and touch at any instant in time and those that are, are firing in response to either these direct external inputs or by the signals propagated by connected neurons that are firing from early external stimulus. Later we will use deep learning neural networks that learn how to self-organize similar hierarchical clusters that recognize specific features in data. Deep learning neural networks often use sparse connections between simulated neurons.

\n\n

One defining feature of human brains is what scientist David Chalmers calls “the hard problem” which is explaining why we have inner thoughts (qualia) that can be daydreams or other thoughts that are independent of external stimulous from our environment. As I write this in February 2017 I know of no AI systems that have such qualia.

\n\n

\nIntroduction to Artificial Neural Networks

\n\n

The following figure shows the simplest type of artificial neural networks which from now on I will simply call “neural networks.” Two input signals X1 and X2 are used to set the activation energy of the two neurons at the bottom of the figure. The connection between the input neuron on the left and the single output neuron is characterized by a weight value W1 and the other input neuron is connected by a weight with a strength W2. To calculate the activation of the output neuron, we multiply the first input neuron’s activation by W1 and add this value from multiplying the second input neuron’s activation by the value W2. In order to keep activation values bounded, the output of a neuron (like the output neuron in this figure) is often gated by a “squashing” function.

\n\n\n

The following figure shows the shape of a typical Sigmoid “squashing function.” Details vary, here the range is [0,1] but some people use a range of [-0.5, 0.5]:

\n\n\n

\"A — A Sigmoid “Squashing” Function (credit: Wikimedia User AI456; image from Wikimedia.org)

\n\n\n

We will use the Sigmoid function for simple feed forward neural networks. Later we will also use the hyperbolic tangent function as a squashing function but the general shape and effect is similar. We will also be using the derivative of the Sigmoid function for learning the connection weights.

\n\n

Imagine a simple neural network (no hidden neurons) with three inputs X1, X2, and X3. These three values define the location of a point in a three-dimensional space, and the “decision surface” is now a two-dimensional plane through this three-dimensional space. The fun begins when we have many inputs. For example, if we have 20 inputs, that defines a 20-dimensional space and if there are no hidden layer neurons then the “decision surface” is a 19-dimensional hyperplane. Don’t worry if you have a difficult time visualizing this - everyone does!

\n\n

If we add a layer of hidden neurons, with two input neurons forming a two-dimensional space, then the decision surface is still a line but the line can be curved.

\n\n

The following figure shows 3 input neurons, 4 “hidden” neurons, and 1 output neuron:

\n\n\n

\"Neural — Neural Network With One Hidden Layer (credit: Wikimedia User SebDE; image from Wikimedia.org)

\n\n\n

In this figure we have three input neurons on the bottom, each input neuron is connected to each of four hidden layer neurons, and each of the four hidden layer neurons is connected to the single output neuron.

\n\n

This neural model is defined by 16 parameters: the values that are learned for each weight in the neural network. Later when we use TensorFlow to work with deep learning we will use neural networks with many layers and thousands or tens of thousands of parameters. For work I train networks with millions of parameters while companies like Google and Microsoft use networks with billions of parameters for tasks like speech recognition and generating natural language descriptions of input images.

\n\n

\nSymbolic Representation of Facts and Rules (Expert Systems)

\n\n

Early artificial intelligence (AI) systems used symbolic representations of the world. Symbolic representations refer to using a symbolic label like “car” to represent cars in the real world. We attempt to represent knowledge with these placeholder symbols and instead of reasoning about real world objects and events we reason with the abstract symbol representations of the real world.

\n\n

As a simple and concrete example, a “person” represents the class of human beings and we might associate attributes like age, weight, and name with instances of this class of entities. In a rule based system, we might define a class “driver” which is a subclass of “person” and a rule that “an instance of class ‘driver’ must have a value greater or equal to 16 for the attribute ‘age’. If we have an instance of “person” named Sam and Sam is 14 years old, then this rule could be used to reason that Sam can not be a driver.

\n\n

Expert systems are built with manually written rules, a storage system for “facts” in the system, and an interpreter for matching rules with facts in a system, running (or “firing”) rules which can add, delete, or modify facts in the system.

\n\n

Historically one of the most important production system interpreters was OPS5 that I used frequently in my work in the 1980s. Another production system is Soar that is a cognitive architecture that includes a rule based system.

\n\n

OPS5 and Soar are not much used now but they have great historic importance in the field of AI. I spent several years in the 1980s working on symbolic expert systems, symbolic knowledge representation schemes like Conceptual dependency theory, and symbolic Natural Language Processing (NLP).

\n\n

\nSymbolic Models for Natural Language Processing

\n\n

Much of the interesting research and practical applications of Natural Language Processing (NLP) are now done using statistical models and deep learning models. We will cover both of these technologies with code examples in some depth in later chapters. Here, for historic reasons, I would like to briefly cover symbolic approaches to NLP.

\n\n

In my work in the 1980s I used Augmented transition networks (ATNs). ATNs were used to parse text using a network where individual nodes can have attached memory to remember things like the subject of a sentence, attributes of nouns used in a sentence, etc. ATNs have the advantage of being fairly simple to write, and a disadvantage that they need to crafted for limited vocabularies. A lot of work can be involved trying to extend them to vocabularies for more than simple topics or applications.

\n\n\n

In this diagram, the node “preposition” will recognize a word that is a preposition, remove the word from the word sequence, and attempt to pass the remaining part of the word sequence to each node connected with an outgoing arrow. When any node sucessfully recognizes the last node in the word sequence, then the trail of nodes represents the parse of the sentence. Consider the following example:

\n\n\n

\"Parsing — Parsing the sentence “the dog ran”

\n\n\n

Here the ATN assigns the part of speech “preposition” to the word “the,” part of speech “noun” to “dog” and the part of speech “verb” to the word “ran.” ATN based systems get very complex when they need to support large vocabularies and they are difficult to maintain.

\n\n

\nUsing Deep Learning for Natural Language Processing

\n\n

TBD

\n\n

\nAn Overview of Linguistics

\n\n

Linguistics is the science of human languages. Although our brains are very general purpose “devices” there is ample evidence that the brain is partially pre-wired to learn languages. Different human languages differ substantially in structure and for simplicity we will consider English.

\n\n

We learn to speak at an early age by interacting with older people. During this process a model of language is formed containing understanding of individual words, words that occur frequently together, and eventually sentence structure, parts of speech, and grammar. Language is so ingrained into how we think that we don’t realize how much we know about language and how it maps to the real physical world and events. At the end of the last chapter we discussed symbols representing things in the real world, but the difference with the human brain is that there is a distributed representation of things stored in neurons and the connections between neurons. When we study deep learning, we will see how these representations are stored in artificial neural networks.

\n\n

Linguistics deals with the study of sounds, the syntactic structure of language, the underlying meanings of words (semantics), and the association of language with background world knowledge that we all have (pragmatics).

\n\n

Computational linguistics is covered in some detail in the next chapter. Here we cover the main ideas of linguistics and define terms that will be useful later. We will use the context of looking at the requirements for a robot that can carry on conversations to take a high level view of the science of linguistics.

\n\n

A robot needs to:

\n\n

Listen to all sounds in a room.
Separate out sounds that are probably human speech in the environment.
Separate out just the speech of the person the robot is talking with.
Perform some form of Fourier analysis to convert frequency information in speech to a power spectral density (think of the volume display on your hifi that shows the volume of bass, mid-range, and higher frequency).
Recognize sub-word sounds (phonemes) and isolate and recognize individual words.
Use an understanding of the structure of sentences and statistics of which words tend occur together to correct errors in word identification.
Understand the context of the human being conversed with and attempt to match incoming words with commands, requests for information, etc.
Build a conversation model from input words, real world understanding, and multiple hypothesis of what the human might want.
Generate speech for the human listener and update the model for what the conversation is about.

\n\n

\nPhonology

\n\n

When we listen to speech, our ears process sound waves that are characterized by power (sound level) and frequency. The ear drum, curved passages in the inner ear, choclea, and choclea nerves capture this information for specific areas of the brain that process sound.

\n\n

Sounds are thus transformed to a distributed representation of phonemes (standard building blocks for constructing words) and sequences of phonemes are transformed into a representation of words, then sentences that we hear.

\n\n

\nMorphology

\n\n

Morphology is the construction of words from sub-parts called morphemes. Consider the word “unhappy” that consists of morphemes “un” and “happy.” The meaning of this word depends on understanding what each constituent morpheme contributes to the meaning of the word.

\n\n

\nSyntax

\n\n

Syntax is different for different languages like Engish, German, Spanish, Chinese, etc. We looked briefly in the last chapter at an ATN that recognized the syntax for a very small subset of English, namely the ability to recognize patterns prepositions -> noun -> verb and prepositions -> adjective -> noun -> verb. When we hear a sentence that does not make sense it might be because we can’t “parse” the syntax or the meaning (semantics) of the sentence makes no sense to us.

\n\n

As an example, “car red go” makes no sense to use syntactically, but viewing the sentence as a “bag of words” (BOW) where we don’t care about word order, we get the general idea the a red car is moving.

\n\n

As another example, “the tree ran fast” does not make sense semantically because in our mental model of the world a tree does not move except for slow growtrh and its branches moving in the wind. A tree can only run in a cartoon.

\n\n

\nSemantics

\n\n

Semantics is the meaning in language. Semantics relies on the understanding of syntax and also on our model for the world (pragmatics).

\n\n

Coupled with semantics is the “grounding problem.” We interpret the color blue through our experiences of seeing a blue sky, blue articles of clothing, etc. An artist thinks more deeply about a color than a typical person. It is an open question whether an AI without a body and the ability to interact with the physical world could ever be a general purpose intelligence.

\n\n

\nPragmatics

\n\n

Pragmatics is a refinement of semantics: the understanding of language in a specific context. This can involve understanding who is in a conversation and what we know about them, and a model of what they may know or not know, and what topics are being discussed.

\n\n

Pragmatics is understanding, or at least partially understanding language.

\n\n

While cognitive computing deals with very specific tasks like adding a calendar entry from a speech request to your cellphone or recognizing what animals are in a picture, general AI (often called AGI - artificial general intelligence) is the science of combining knowlege of the world, language, knowlege of performing tasks, etc. into integrated systems.

\n\n

NLP, including pragmatics, is a good step towards development of general AIs.

\n\n

\nLinguistics Wrap Up And Practical Applications

\n\n

We just took an overview of the field of linguistics and we studied how linguistics fits into the study of cognition. Later we will ground the theory seen here with practical examples of processing natural language text. I use the terms Natural Language Processing (NLP) and Computational Linguistics to mean almost the same thing with the difference being that NLP is more a collection of software engineering techniques and practices to process and extract information from text while Computational Linguistics deals more with the science of understanding linguistics and thus to some degree cognition.

\n\n

We will later look at several practical examples of NLP:

\n\n

Using Convolutional Neural Networks for classifying text
Using the spaCY library for part of speech tagging, and entity detection
Using the OpenNLP library for classifying text
Using the OpenNLP library for Recognizing Entity Names in Text

\n\n

\nThe Public’s Perception of Artificial Intelligence

\n\n

I started working in the field of AI in the early 1980s and there were relatively few of us back then. Now various subfields of AI and cognitive computing are some of the fastest growing segments of the tech sector. For the general public there are at least three topics that have attracted attention:

\n\n

IBM’s Deep Blue defeating world chess champion Garry Kasparov in 1997
Google/DeepMind’s AlphaGo defeating Lee Sedol who is one of the strongest Go players in the world in 2016
AI and automation “taking people’s jobs”

\n\n

The game of Go is of particular interest to me personally because I wrote the world’s first commercially available Go playing program “Honinbo Warrior” for the Apple II computer. I wrote this program in UCSD Pascal. Around the same time I also had the opportunity to play the national Go champian of South Korea and the women’s world Go champion. I am a big fan of the game and I argue that it is much more complex than chess. AlphaGo’s victory over Lee Sedol in the spring of 2016 was a watershed moment in AI and I watched the games played live on the Internet. I felt that I was living through an important moment in history. Exciting times!

\n\n

The issue of AI computing systems replacing most human workers is almost a certainty and the sociological challenge of dealing with unemployment is probably greater than the technical challenges for accomplishing this. It is currently an open debate whether future AIs will pose a danger to the human race but in spite of rapid advances in our field, I don’t worry about this problem - at least not yet.

\n\n\n

\nPython Tips and Techniques

\n\n

TBD

\n\n\n

\nEthics and Human Values

\n\n

Artificial Intelligence (AI) systems will have dramatic influence on our lives and decisions made today on the level of effort spent on imbuing AI systems with our values as human beings is important. I feel that understanding ethical questions is an important part of being an AI practitioner.

\n\n

Part of writing ethical AI systems, especially deep learning models, is ensuring that data that we use for training is free of bias. A well known class of cases of biased data involves data that may not represent all races and ethnicities fairly.

\n\n

By human values I mean personal values that each of us makes that indicate how important family, helping people, wealth, personal safety, safety of others, relative importance of personal vs. community goals, education, world peace, etc. are.

\n\n

Assuming the field of AI continues to make rapid progress, I believe that sentient AIs will eventually be built and some safeguards need to be in place to offer some guarantee that they will have our values. Decisions need to be made on what types of AIs we will build, military use of AIs, etc.

\n\n

I don’t think that leaving these decisions to large corporations and our governments is a real solution. Rather, as AI practitioners we should question the data that we use and the fairness of algorythms. Think for a moment how AI systems that utilize our personal data from being on the web affects us. To use Amazon as an example, how often are you tempted to buy something that Amazon “thinks you might be interested in” even though you had no intention of buying that item when you logged on to their web site? Do you know people who married their spouses based on the AI recommendation of an online dating system? I think it is obvious that many people will lose their jobs to AI systems in the future, and considering the effects on society is important, but isn’t it also important to consider our own personal feelings and control of our lives?

\n\n

Let’s look at an example. Consider your personal ideas of how much you value your own safety vs. the safety of others. Sometime in the future you will use a self driving car. Would you want your car to save your life as the only passenger in your vehicle if it meant running a car full of passengers off the road and killing them? Setting aside the legal implications, it is not too much off a stretch to envision the idea of personalizing the values of cognitive systems that act on our behalf. Another example of where we would prefer that our personal values be taken into account in cognitive systems might be education: would you want your young children or grandchildrens’ social groups in preschool and kindergarten to be automated by AI systems that group kids into play groups based on big data and machine learning? I think not!

\n\n

I believe it is well within the topic of this book to at least discuss and think about ways in which the cognitive systems we build should be consistent to our personal values as developers and/or the values of people who use these systems.

\n\n

What can we do right now to reflect our human values in the actions of systems that we create? I offer one suggestion: when we use machine learning, consider parameterizing relevant values and include them in training data. This could be as simple as considering the values of caring for the environment and effect on poor regions of the world when building an AI system to choose companies to invest in. Whether a user cares or does not care about these issues should affect the results produced by an investment model.

\n\n

TBD: provide references to my 2 favorite privacy books

\n\n\n

\nPart II - Machine Learning and Deep Learning

\n\n

Here we start the “cookbook” part of this book that comprises many small program examples to solve specific problems that I expect you may encounter in your work.

\n\n

When I started working in the field of AI in 1982 everything I did was symbolic AI and this lasted until 1988 when I started using neural networks to solve practical engineering problems at work, participated in a one year DARPA neural network advisory panel, and wrote the first version of the SAIC ANSim neural network toolkit. Since then most of my work has involved machine learning and specifically neural networks but I was motivated to include the overview material on symbolic AI in this book because I don’t personally believe that distributed neural network machine learning is the final word in cognitive computing and AI. I think that the next major advancement in our field will be hybrid symbolic and neural systems so mentioning symbolic AI seems appropriate.

\n\n\n

\n(Almost) Everything You Really Need To Know About Machine Learning

\n\n

In this chapter we will look at modern best practices for machine learning. I will cover some theory with simple implementations that you can use for experimenting and for small or medium scale machine learning tasks. For larger scale problems we will cover Google’s TensorFlow system in later. This is a practical chapter for you to learn some theory and some practical techniques and also later use as a reference. I will use the notation that Andrew Ng uses in his online Machine Learning Class at Coursera. I highly recommend this class!

\n\n

TBD: update above to more modern courses

\n\n

\nIntroduction to Supervised and Unsupervised Learning

\n\n

When we train a model, what are we really doing? We start with training cases that represent data similar to what we might need to process in the future and we want to use existing data to build a model or prescription for processing similar data.

\n\n

In supervised learning the representative training data includes both example inputs and the desired output for each example input. An important concept is building a generalized model, and not simply a memory system that remembers the training inputs and outputs. A model that simply remembers the training examples and does not generalize is said to suffer from over fitting. In later chapters we will look at TensorFlow examples that optionally can use two state of the art techniques for reducing over fitting: regularization and drop out but in this chapter we will prevent over fitting by limiting the number of parameters in a model and by training with a sufficient amount of data. In the case of simple neural networks, model parameters are the weights of connections between neurons. For more complicated deep learning neural networks, we also have hyper-parameters that specify the number of neuron layers, the degree connections (weights) between neurons in adjacent layers, etc.

\n\n

Models have specific learned parameters. Most of the machine learning examples in this book involve neural networks and in this case the learned models are the weight values in the neural network covered in the first chapter that introduced cognitive computing. Other types of learned parameters are the hypothesis coefficients in linear regression models.

\n\n

In all types of learned models, regularization refers to penalizing models with large valued learned parameters. When we train a model, we use a cost function to measure “how far off” a model is from the desired behavior, with smaller values of the cost function being better (in the sense of improving accuracy). If learned parameters are large, the cost function is increased by using a constant called the regularization constant and a measurement for how large (in absolute value) the learned parameters are.

\n\n

The idea of using dropouts is specific to more complex deep learning neural networks. As you know from the introduction to cognitive computing in the first chapter, neural networks consist or simulated neurons and the connections between them. We randomly turn off a subset of neurons during training and also not modifying connection weights between “dropped” neurons and other neurons. Using dropouts allows us to use very complex networks (both in the number of layers and the number of neurons in each layer) without over fitting the training data.

\n\n

Even though we will not cover unsupervised learning in this book, I wanted to mention situations where you may want to process training data that is only inputs with no desired outputs. This might seem counterintuitive to you so let’s look at an example of unsupervised learning: clustering unlabelled data into different sets. Data might be a set of all PDF documents in a company’s content management system. If the documents are unlabelled as to clasifiction we can still automatically cluster them into sets of similar documents. An interesting feature of unsupervised clustering, a “feature” that is sometimes a problem, is that the clusters do not have human recognizable names or identities. It might be that the PDF files in a content management system might be in rough categories HR, Sales, and Finance. Further, hopefully an unsupervised learning system would separate documents into three different unnamed categories. After automatic clustering occurs, a human reader can look at the auto-generated document sets and label then with tags “HR”, etc. When there is labelled training data available, it is more intuitive to use supervised learning. We will primarily use supervised learning in this book. If you are interested in unsupervised clustering, I have KMeans clustering examples you can work with in my book Power Java.

\n\n

\nFeature Engineering

\n\n

A large advantage of deep learning is automatically determining features that are important in data for any specific task. Neural network architecture is still important, but much of the manual effort of feature selection is handled fair automatically by deep learning networks. I will use an example of something I worked on as an example of the “old way” of manual feature selection and precalculating features: time delay neural networks (recurrent neural networks) to recognize phonemes in digitized audio of a human speaker. In the 1980s when I did this work, I preprocessed the data from sound wave data by sliding a window through the data, taking a Fast forier Transfom (FFT) of the data, squaring the data to form a power spectral density, and selecting the frequency bands that might be must useful for phoneme recognition. Even being guided from the results of a paper by Alex Waibel on the subject, determining which features to use and tuning parameters like window size, etc. was a lot of effort. Recent work has used a deep learning network with input of raw time series audio data. The network learns effectively how to do a fourier transform and other feature definition all on its own. If I had modern libraries like TensorFlow in the 1980s I would have saved a lot of development time and achieved better results.

\n\n

I still believe that it is extremely important for machine learning practitioners to be skilled at feature identification, extraction, and general data preparation. Don’t rely solely on deep learning. In this section we review some examples and techniques.

\n\n

Understanding your data is key to using machine learning techniques. Understanding the features in data is a key part of data cleaning activities. Regardless of whether you use techniques that we will later use like maximum entropy classification models, neural networks for recognizing images or performing natural language processing, etc., once you learn how to use available open source machine learning libraries, you will find that much of your time will be spend understanding your data, cleaning your data, organizing data for reuse and multiple uses, etc.

\n\n

\nFeature Engineering for Text Data

\n\n

There are several ways to look at text data: character by character, tokenized into a stream of words, a stream of stemmed words, segmented into individual sentences, keep extra punctuation like commas, semicolons, keep surrounding quotation marks or remove them, etc. Text collections are often converted to a matrix notation using the following scheme:

\n\n

Maintain a dictionary of unique words where each word is mapped to an integer index from zero to the number of unique words minus one.
Input text is stored with documents represented as rows in the matrix while the column values are zero if the word index at a column index rows not appear in a document or as a value of 1 if the document does contain the word mapped to a column index.

\n\n

Other representations of inputs texts include a “bag of words” or “bag of ngrams.” A “bag of words” (BOW) is the set of unique words in an input document. Ngrams are instances of adjacent words in text. A 1gram is a single word, a 2gram is two words that appear adjacent to each other, a 3gram is three adjacent words, etc.

\n\n

\nFeature Engineering for Numeric Data

\n\n

Here we will be concerned with data represented as a one-dimensional vector of numeric values. For data at each index in an input vector, it is common to:

\n\n

Normalize data to a specific range ([0.0, 1.0] or [-1.0, 1.0] are common ranges)
Subtract the mean value at each index (e.g., data at a specific index that occurs in the range [1000, 2000] with a mean value of 1200 might have the mean subtracted from each input value with the resulting data normalized to the range [0.0, 1.0])
Take the log of data. This technique is often used when developing anomly detection systems for any parmeters that do not have a Gausian distribution.

\n\n

It might seem that considering one-dimensional data is limiting, but even image data is usually treated as a one-dimensional vector. For example, a black and white image that is 64x64 pixels might be “linearized” to a one-dimension vector with 4096 elements and the value of each pixel might be mapped to the range [0.0, 1.0] where 0.0 represents black pixels, 1.0 represents white pixels, with grey-scale values following between 0.0 and 1.0.

\n\n\n

\nTensoflow and Keras Model for Wisconsin Cancer Data Set

\n\n

TBD

\n\n

\nJupyter Notebook

\n\n

You can find a copy of this notebook here on Google Colab wisconsin_data_github.ipynb

\n\n

TBD describe:

\n\n

1 test_uri = \"https://raw.githubusercontent.com/mark-watson/cancer-deep-learning-model\\\n2 /master/test.csv\"\n3 train_uri = \"https://raw.githubusercontent.com/mark-watson/cancer-deep-learning-mode\\\n4 l/master/train.csv\"\n5 \n6 %load_ext tensorboard\n7 \n8 !pip install skimpy # might require restarting the runtime\n

\n\n\n\n

TBD

\n\n

 1 from keras.models import Sequential # Keras by default imports and uses Tensorflow\n 2 from keras.layers import Dense, Dropout\n 3 from keras import optimizers\n 4 from keras.callbacks import TensorBoard\n 5 import tensorflow as tf\n 6 import pandas\n 7 import os\n 8 import datetime\n 9 from skimpy import skim\n10 \n11 train_df = pandas.read_csv(train_uri, header=None)\n12 \n13 skim(train_df)\n14 \n15 train = train_df.values\n16 X_train = train[:,0:9].astype(float) # 9 inputs\n17 print(\"Number training examples:\", len(X_train))\n18 Y_train = train[:,-1].astype(float)  # one target output (0 for no cancer, 1 for mal\\\n19 ignant)\n20 test = pandas.read_csv(test_uri, header=None).values\n21 X_test = test[:,0:9].astype(float)\n22 Y_test = test[:,-1].astype(float)\n23 \n24 model = Sequential()\n25 model.add(Dense(tf.constant(15), input_dim=tf.constant(9), activation='relu'))\n26 model.add(Dense(tf.constant(15), input_dim=tf.constant(15), activation='relu'))\n27 model.add(Dropout(0.2)),\n28 model.add(Dense(tf.constant(1), activation='sigmoid'))\n29 model.summary()\n30 \n31 model.compile(optimizer='sgd',\n32               loss='mse',\n33               metrics=['accuracy'])\n34 \n35 logdir = os.path.join(\"logs\", datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n36 callbacks = [TensorBoard(log_dir=logdir,histogram_freq=1,write_graph=True, write_ima\\\n37 ges=True)]\n38 \n39 \n40 model.fit(X_train, Y_train, batch_size=100, epochs=60, callbacks=callbacks)\n41 \n42 # no cancer and malignant test samples:\n43 y_predict = model.predict([[4,1,1,3,2,1,3,1,1], [3,7,7,4,4,9,4,8,1]])\n44 \n45 print(\"* y_predict (should be close to [[0], [1]]):\", y_predict)\n

\n\n\n\n

TBD describe:

\n\n

1 # !pip install -U tensorboard-plugin-profile\n2 \n3 %tensorboard --logdir logs\n

\n\n\n\n

Skimpy output for trainign data:

\n\n\n

\n\n\n\n

\n\n\n\n

\nUsing TensorFlow for Implementing Deep Neural Networks

\n\n

There are several open source libraries and frameworks for implementing deep learning neural networks. We will look at two examples in this chapter: processing numeric cancer data to build a predictive model and for using a convolutional network for text classification. Many deep learning examples you might see on the web use image recognition as an example application but I allow myself to concentrate here on two types of problems that I use deep learning networks in my own work. In the original edition of this book both of these examples used TensorFlow; in this revised edition, I use the higher-level Keras APIs with a TensorFlow backend in the first example.

\n\n

It is worth mentioning other good deep learning toolkits:

\n\n

\nKeras is a high level library for specifying deep networks and can use the lower level Tensorflow and Theano as back ends. Keras is especially good for rapidly prototyping different network architectures. Recommended!
\nTheano is a lower level library that supports both CPU and GPU execution models.
\nCaffe is a widely used C++ library for using deep neural netowkrs for image recognition.
\nmxnet is another widely used deep learning library written in C++. One useful feature is language bindings for Python, R, Julia, Scala, Go, and Javascript.
\nDeeplearning4j (Deep Learning for Java) is a library written for the JVM. I covered Deeplearning4j in my book Power Java with examples for deep belief networks. I especially like DeepLearning4j for deployment in production environments that use the JVM platform.

\n\n

\nInstalling TensorFlow and Keras

\n\n

We will use Python 3.9 for examples in this book. Check Appendix A for detailed installation instructions. After working through the examples in this chapter, you may want to read through and experiment with Google’s TensorFlow examples as well as the examples on the Keras website.

\n\n

\nProcessing Cancer Data With a BackPropagation Network

\n\n

This example is found in the subdirectory tensorflow_examples/cancer_deep_learning_model in the github repository for this book. We will use the Universary of Wisconsin Cancer Data that is in the file train.csv that has the following format:

\n\n

- 0 Clump Thickness               1 - 10\n- 1 Uniformity of Cell Size       1 - 10\n- 2 Uniformity of Cell Shape      1 - 10\n- 3 Marginal Adhesion             1 - 10\n- 4 Single Epithelial Cell Size   1 - 10\n- 5 Bare Nuclei                   1 - 10\n- 6 Bland Chromatin               1 - 10\n- 7 Normal Nucleoli               1 - 10\n- 8 Mitoses                       1 - 10\n- 9 Class (0 for benign, 1 for malignant)\n

\n\n\n\n

We will use a feedforward network with two hidden layers, each hidden layer containing twelve fully connected neurons. A single output layer neuron using the sigmoid activation function will have values in the range zero to one. The network will be trained to output a small (close to zero) value for input non-cancer samples and output large values (close to one) for malignant input samples. In the following listing, lines 1-4 import the Keras (which requires and imports Tensorflow) and pandas libraires. The pandas library is using to read and write arrays as well as provide matrix operations. Pandas requires and loads the numy library that supplies data types and functionality for handling matrix operations.

\n\n

We will train the network using the file train.csv and then test the trained network with different data defined in the file test.csv. We load these two datafiles using the pandas library in lines 7-12.

\n\n

In lines 14-18 we define the Keras sequential model. We add two dense (i.e., fully connected) layers with shapes (9,12) and (12,12) and an output layer with a single neuron whose value is taken as the probability that an input sample is malignant. The first two hidden layers use a ReLU activation function which is now more often used than a Sigmoid activation function because of more efficient gradient propagation that helps prevent vanishing or exploding gradient problems during training. The output of a Sigmoid activation can be interpreted as a probability between zero and one and using Sigmoid function activation in the output layer is fairly much a standard procedure.

\n\n

Keras allows us to register callbacks to save the model, create log data for TensorBoard visualization, early stopping of training, etc. Here we create a callback in lines 24-25 to write log data for TensorBoard.

\n\n

We use the trained model with the test.csv test set icalculate the accuracy over all samples in the test data (Accuracy: 0.96) and in lines 32 I show you how to use the trained model with arbitrary new test data.

\n\n

TBD: update the following example

\n\n

 1 from keras.models import Sequential # Keras by default imports Tensorflow\n 2 from keras.layers import Dense\n 3 from keras import optimizers\n 4 from keras.callbacks import TensorBoard\n 5 import pandas\n 6 \n 7 train = pandas.read_csv(\"train.csv\", header=None).values\n 8 X_train = train[:,0:9].astype(float) # 9 inputs\n 9 Y_train = train[:,-1].astype(float)  # target output (0 no cancer, 1 malignant)\n10 test = pandas.read_csv(\"test.csv\", header=None).values\n11 X_test = test[:,0:9].astype(float)\n12 Y_test = test[:,-1].astype(float)\n13 \n14 model = Sequential()\n15 model.add(Dense(12, input_dim=9, activation='relu'))\n16 model.add(Dense(12, input_dim=12, activation='relu'))\n17 model.add(Dense(1, activation='sigmoid'))\n18 model.summary()\n19 \n20 model.compile(optimizer=optimizers.RMSprop(lr=0.002),\n21               loss='mse',\n22               metrics=['accuracy'])\n23 \n24 callbacks = [TensorBoard(log_dir='logdir', histogram_freq=0,\n25                          write_graph=True, write_images=False)]\n26 \n27 model.fit(X_train, Y_train, batch_size=24, epochs=10, callbacks=callbacks)\n28 \n29 # no cancer and malignant test samples:\n30 y_predict = model.predict([[4,1,1,3,2,1,3,1,1], [3,7,7,4,4,9,4,8,1]])\n31 \n32 print(\"* y_predict (should be close to [0, 1]):\", y_predict)\n

\n\n\n\n

I assume that you have TensorFlow and Keras installed. Run the example using:

\n\n

 1 cancer_deep_learning_model$  export TF_CPP_MIN_LOG_LEVEL=2\n 2 cancer_deep_learning_model$  source activate tensorflow27\n 3 (tensorflow) cancer_deep_learning_model$ python cancer_trainer.py\n 4 Using TensorFlow backend.\n 5 _________________________________________________________________\n 6 Layer (type)                 Output Shape              Param #   \n 7 =================================================================\n 8 dense_1 (Dense)              (None, 12)                120       \n 9 _________________________________________________________________\n10 dense_2 (Dense)              (None, 12)                156       \n11 _________________________________________________________________\n12 dense_3 (Dense)              (None, 1)                 13        \n13 =================================================================\n14 Total params: 289\n15 Trainable params: 289\n16 Non-trainable params: 0\n17 _________________________________________________________________\n18 Epoch 1/10\n19 497/497 [==============================] - 0s - loss: 0.2684 - acc: 0.3742     \n20 Epoch 2/10\n21 497/497 [==============================] - 0s - loss: 0.2110 - acc: 0.6459     \n22 Epoch 3/10\n23 497/497 [==============================] - 0s - loss: 0.1840 - acc: 0.7807     \n24 Epoch 4/10\n25 497/497 [==============================] - 0s - loss: 0.1559 - acc: 0.8531     \n26 Epoch 5/10\n27 497/497 [==============================] - 0s - loss: 0.1285 - acc: 0.9095     \n28 Epoch 6/10\n29 497/497 [==============================] - 0s - loss: 0.1079 - acc: 0.9276     \n30 Epoch 7/10\n31 497/497 [==============================] - 0s - loss: 0.0894 - acc: 0.9437     \n32 Epoch 8/10\n33 497/497 [==============================] - 0s - loss: 0.0747 - acc: 0.9437     \n34 Epoch 9/10\n35 497/497 [==============================] - 0s - loss: 0.0618 - acc: 0.9537     \n36 Epoch 10/10\n37 497/497 [==============================] - 0s - loss: 0.0528 - acc: 0.9598     \n38 * y_predict (should be close to [0, 1]): [[ 0.10986128]\n39  [ 0.99367613]]\n

\n\n\n\n

We can use the tensorbard utility (installed with Tensorflow) to look at the status of the loss function during training:

\n\n

tensorboard –logdir=logdir –port=8080

\n\n

If you open a web browser to http://localhost:8080 you will get the interactive TensorBoard display.

\n\n\n

\nDeep Learning Wrap Up

\n\n

The tutorials at tensorflow.org provide many examples of using TensorFlow. Deep learning neural networks have rapidly advanced state of the art performance in many application areas. At the natural language processing conference NAACL 2016, it seemed that about half the papers reported results using deep learning neural networks.

\n\n

Regardless of your application, you are likely to find both academic papers and example systems solving similar problems using Tesnsorflow or other deep learning libraries. I recommend that you also look at Google’s Tensorflow examples.

\n\n

Two other learning resources that I strongly recommend are:

\n\n

The five course Deep Learning series by Andrew Ng produced by Coursera and deeplearning.ai\n
A new book by Francois Chollet who is the author of Keras: Deep Learning with Python that is a great resource for using Keras to solve practical deep learning problems.

\n\n

In the next chapter we continue to look at examples of natural language processing using more conventional maximum entropy machine learning models.

\n\n\n

\nGenerating Images With Deep Learning

\n\n

TBD - use the Collar example I have

\n\n\n

\nPart III - Natural Language Processing

\n\n

In the 1980s I used symbolic AI to implement natural language processing (NLP) systems. Today most meaningful work in NLP depends heavily on deep learning.

\n\n

My goal is to teach you how to use the most effective NLP technologies. I will not discuss in any detail the history of NLP and I will ignore classes of problems that you are unlikely to encounter in your work.

\n\n\n

\nIntroduction to Natural Language Processing

\n\n

I have been working in the field of Natural Language Processing (NLP) since 1985 so I ‘lived through’ the revolutionary change in NLP that has occurred since 2014: deep learning results out-classed results from previous symbolic methods.

\n\n

I will not cover older symbolic methods of NLP here, rather I refer you to my previous books Practical Artificial Intelligence Programming With Java, [Loving Common Lisp, The Savvy Programmer’s Secret Weapon, and Haskell Tutorial and Cookbook for examples. We get better results using Deep Learning (DL) for NLP and the library spaCy (https://spacy.io) that we use in this chapter provides near state of the art performance. The authors of spaCy frequently update it to use the latest breakthroughs in the field.

\n\n

You will learn how to apply both DL and NLP by using the state-of-the-art full-feature library spaCy. This chapter concentrates on how to use spaCy in the Hy language for solutions to a few selected problems in NLP that I use in my own work. I urge you to also review the “Guides” section of the spaCy documentation where examples are in Python but after experimenting with the examples in this chapter you should have no difficulty in translating any spaCy Python examples to the Hy language.

\n\n

If you have not already done so install the spaCy library and the full English language model:

\n\n

pip install spacy\npython -m spacy download en\n

\n\n\n\n

You can use a smaller model (which requires loading “en_core_web_sm” instead of “en” in the following examples):

\n\n

pip install spacy\npython -m spacy download en_core_web_sm\n

\n\n\n\n

\nExploring the spaCy Library

\n\n

We will use the Hy REPL to experiment with spaCy, Lisp style. The following REPL listings are all from the same session, split into separate listings so that I can talk you through the examples:

\n\n

 1 Marks-MacBook:nlp $ hy\n 2 hy 0.17.0+108.g919a77e using CPython(default) 3.7.3 on Darwin\n 3 => (import spacy)\n 4 => (setv nlp-model (spacy.load \"en\"))\n 5 => (setv doc (nlp-model \"President George Bush went to Mexico and he had a very good\\\n 6  meal\"))\n 7 => doc\n 8 President George Bush went to Mexico and he had a very good meal\n 9 => (dir doc)\n10 ['_', '__bytes__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__fo\\\n11 rmat__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init_\\\n12 _', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new\\\n13 __', '__pyx_vtable__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__\\\n14 setstate__', '__sizeof__', '__str__', '__subclasshook__', '__unicode__', '_bulk_merg\\\n15 e', '_py_tokens', '_realloc', '_vector', '_vector_norm', 'cats', 'char_span', 'count\\\n16 _by', 'doc', 'ents', 'extend_tensor', 'from_array', 'from_bytes', 'from_disk', 'get_\\\n17 extension', 'get_lca_matrix', 'has_extension', 'has_vector', 'is_nered', 'is_parsed'\\\n18 , 'is_sentenced', 'is_tagged', 'lang', 'lang_', 'mem', 'merge', 'noun_chunks', 'noun\\\n19 _chunks_iterator', 'print_tree', 'remove_extension', 'retokenize', 'sentiment', 'sen\\\n20 ts', 'set_extension', 'similarity', 'tensor', 'text', 'text_with_ws', 'to_array', 't\\\n21 o_bytes', 'to_disk', 'to_json', 'user_data', 'user_hooks', 'user_span_hooks', 'user_\\\n22 token_hooks', 'vector', 'vector_norm', 'vocab']\n

\n\n\n\n

In lines 3-6 we import the spaCy library, load the English language model, and create a document from input text. What is a spaCy document? In line 9 we use the standard Python function dir to look at all names and functions defined for the object doc returned from applying a spaCy model to a string containing text. The value printed shows many built in “dunder” (double underscore attributes), and we can remove these:

\n\n

In lines 23-26 we use the dir function again to see the attributes and methods for this class, but filter out any attributes containing the characters “__”:

\n\n

23 => (lfor\n24 ... x (dir doc)\n25 ... :if (not (.startswith x \"__\"))\n26 ... x)\n27 ['_', '_bulk_merge', '_py_tokens', '_realloc', '_vector', '_vector_norm', 'cats', 'c\\\n28 har_span', 'count_by', 'doc', 'ents', 'extend_tensor', 'from_array', 'from_bytes', '\\\n29 from_disk', 'get_extension', 'get_lca_matrix', 'has_extension', 'has_vector', 'is_ne\\\n30 red', 'is_parsed', 'is_sentenced', 'is_tagged', 'lang', 'lang_', 'mem', 'merge', 'no\\\n31 un_chunks', 'noun_chunks_iterator', 'print_tree', 'remove_extension', 'retokenize', \\\n32 'sentiment', 'sents', 'set_extension', 'similarity', 'tensor', 'text', 'text_with_ws\\\n33 ', 'to_array', 'to_bytes', 'to_disk', 'to_json', 'user_data', 'user_hooks', 'user_sp\\\n34 an_hooks', 'user_token_hooks', 'vector', 'vector_norm', 'vocab']\n35 =>\n

\n\n\n\n

The to_json method looks promising so we will import the Python pretty print library and look at the pretty printed result of calling the to_json method on our document stored in doc:

\n\n

 36 => (import [pprint [pprint]])\n 37 => (pprint (doc.to_json))\n 38 {'ents': [{'end': 21, 'label': 'PERSON', 'start': 10},\n 39           {'end': 36, 'label': 'GPE', 'start': 30}],\n 40  'sents': [{'end': 64, 'start': 0}],\n 41  'text': 'President George Bush went to Mexico and he had a very good meal',\n 42  'tokens': [{'dep': 'compound',\n 43              'end': 9,\n 44              'head': 2,\n 45              'id': 0,\n 46              'pos': 'PROPN',\n 47              'start': 0,\n 48              'tag': 'NNP'},\n 49             {'dep': 'compound',\n 50              'end': 16,\n 51              'head': 2,\n 52              'id': 1,\n 53              'pos': 'PROPN',\n 54              'start': 10,\n 55              'tag': 'NNP'},\n 56             {'dep': 'nsubj',\n 57              'end': 21,\n 58              'head': 3,\n 59              'id': 2,\n 60              'pos': 'PROPN',\n 61              'start': 17,\n 62              'tag': 'NNP'},\n 63             {'dep': 'ROOT',\n 64              'end': 26,\n 65              'head': 3,\n 66              'id': 3,\n 67              'pos': 'VERB',\n 68              'start': 22,\n 69              'tag': 'VBD'},\n 70             {'dep': 'prep',\n 71              'end': 29,\n 72              'head': 3,\n 73              'id': 4,\n 74              'pos': 'ADP',\n 75              'start': 27,\n 76              'tag': 'IN'},\n 77             {'dep': 'pobj',\n 78              'end': 36,\n 79              'head': 4,\n 80              'id': 5,\n 81              'pos': 'PROPN',\n 82              'start': 30,\n 83              'tag': 'NNP'},\n 84             {'dep': 'cc',\n 85              'end': 40,\n 86              'head': 3,\n 87              'id': 6,\n 88              'pos': 'CCONJ',\n 89              'start': 37,\n 90              'tag': 'CC'},\n 91             {'dep': 'nsubj',\n 92              'end': 43,\n 93              'head': 8,\n 94              'id': 7,\n 95              'pos': 'PRON',\n 96              'start': 41,\n 97              'tag': 'PRP'},\n 98             {'dep': 'conj',\n 99              'end': 47,\n100              'head': 3,\n101              'id': 8,\n102              'pos': 'VERB',\n103              'start': 44,\n104              'tag': 'VBD'},\n105             {'dep': 'det',\n106              'end': 49,\n107              'head': 12,\n108              'id': 9,\n109              'pos': 'DET',\n110              'start': 48,\n111              'tag': 'DT'},\n112             {'dep': 'advmod',\n113              'end': 54,\n114              'head': 11,\n115              'id': 10,\n116              'pos': 'ADV',\n117              'start': 50,\n118              'tag': 'RB'},\n119             {'dep': 'amod',\n120              'end': 59,\n121              'head': 12,\n122              'id': 11,\n123              'pos': 'ADJ',\n124              'start': 55,\n125              'tag': 'JJ'},\n126             {'dep': 'dobj',\n127              'end': 64,\n128              'head': 8,\n129              'id': 12,\n130              'pos': 'NOUN',\n131              'start': 60,\n132              'tag': 'NN'}]}\n133 => \n

\n\n\n\n

The JSON data is nested dictionaries. In a later chapter on Knowledge Graphs, we will want to get the named entities like people, organizations, etc., from text and use this information to automatically generate data for Knowledge Graphs. The values for the key ents (stands for “entities”) will be useful. Notice that the words in the original text are specified by beginning and ending text token indices (values of head and end in lines 52 to 142).

\n\n

The values for the key tokens listed on lines 42-132 contains the head (or starting index, ending index, the token number (id), and the part of speech (pos). We will list what the parts of speech mean later.

\n\n

We would like the words for each entity to be concatenated into a single string for each entity and we do this here in lines 136-137 and see the results in lines 138-139.

\n\n

I like to add the entity name strings back into the dictionary representing a document and line 140 shows the use of lfor to create a list of lists where the sublists contain the entity name as a single string and the type of entity. We list the entity types supported by spaCy in the next section.

\n\n

134 => doc.ents\n135 (George Bush, Mexico)\n136 => (for [entity doc.ents]\n137 ... (print \"entity text:\" entity.text \"entity label:\" entity.label_))\n138 entity text: George Bush entity label: PERSON\n139 entity text: Mexico entity label: GPE\n140 => (lfor entity doc.ents [entity.text entity.label_])\n141 [['George Bush', 'PERSON'], ['Mexico', 'GPE']]\n142 => \n

\n\n\n\n

We can also access each sentence as a separate string. In this example the original text used to create our sample document had only a single sentence so the sents property returns a list containing a single string:

\n\n

147 => (list doc.sents)\n148 [President George Bush went to Mexico and he had a very good meal]\n149 => \n

\n\n\n\n

The last example showing how to use a spaCy document object is listing each word with its part of speech:

\n\n

150 => (for [word doc]\n151 ... (print word.text word.pos_))\n152 President PROPN\n153 George PROPN\n154 Bush PROPN\n155 went VERB\n156 to ADP\n157 Mexico PROPN\n158 and CCONJ\n159 he PRON\n160 had VERB\n161 a DET\n162 very ADV\n163 good ADJ\n164 meal NOUN\n165 => \n

\n\n\n\n

The following list shows the definitions for the part of speech (POS) tags:

\n\n

ADJ: adjective
ADP: adposition
ADV: adverb
AUX: auxiliary verb
CONJ: coordinating conjunction
DET: determiner
INTJ: interjection
NOUN: noun
NUM: numeral
PART: particle
PRON: pronoun
PROPN: proper noun
PUNCT: punctuation
SCONJ: subordinating conjunction
SYM: symbol
VERB: verb
X: other

\n\n

\nImplementing a HyNLP Wrapper for the Python spaCy Library

\n\n

We will generate two libraries (in files nlp_lib.hy and coref_nlp_lib.hy). The first is a general NLP library and the second specifically solves the anaphora resolution, or coreference, problem. There are test programs for each library in the files nlp_example.hy and coref_example.hy.

\n\n

For an example in a later chapter, we will use the library developed here to automatically generate Knowledge Graphs from text data. We will need the ability to find person, company, location, etc. names in text. We use spaCy here to do this. The types of named entities on which spaCy is pre-trained includes:

\n\n

CARDINAL: any number that is not identified as a more specific type, like money, time, etc.
DATE
FAC: facilities like highways, bridges, airports, etc.
GPE: Countries, states (or provinces), and cities
LOC: any non-GPE location
PRODUCT
EVENT
LANGUAGE: any named language
MONEY: any monetary value or unit of money
NORP: nationalities or religious groups
ORG: any organization like a company, non-profit, school, etc.
PERCENT: any number in [0, 100] followed by the percent % character
PERSON
ORDINAL: any number spelled out, like “one”, “two”, etc.
TIME

\n\n

Listing for hy-lisp-python/nlp/nlp_lib.hy:

\n\n

 1 (import spacy)\n 2 \n 3 (setv nlp-model (spacy.load \"en\"))\n 4 \n 5 (defn nlp [some-text]\n 6   (setv doc (nlp-model some-text))\n 7   (setv entities (lfor entity doc.ents [entity.text entity.label_]))\n 8   (setv j (doc.to_json))\n 9   (setv (get j \"entities\") entities)\n10   j)\n

\n\n\n\n

Listing for hy-lisp-python/nlp/nlp_example.hy:

\n\n

1 #!/usr/bin/env hy\n2 \n3 (import [nlp-lib [nlp]])\n4 \n5 (print\n6   (nlp \"President George Bush went to Mexico and he had a very good meal\"))\n7 \n8 (print\n9   (nlp \"Lucy threw a ball to Bill and he caught it\"))\n

\n\n\n\n

1 Marks-MacBook:nlp $ ./nlp_example.hy\n2 {'text': 'President George Bush went to Mexico and he had a very good meal', 'ents':\\\n3  [{'start': 10, 'end': 21, 'label': 'PERSON'}, {'start': 30, 'end': 36, 'label': 'GP\\\n4 E'}], 'sents': [{'start': 0, 'end': 64}], 'tokens': \n5 \n6   ..LOTS OF OUTPUT NOT SHOWN..\n

\n\n\n\n

\nCoreference (Anaphora Resolution)

\n\n

Another common NLP task is coreference (or anaphora resolution) which is the process of resolving pronouns in text (e.g., he, she, it, etc.) with preceding proper nouns that pronouns refer to. A simple example would be translating “John ran fast and he fell” to “John ran fast and John fell.” This is an easy example, but often proper nouns that pronouns refer to are in previous sentences and resolving coreference can be ambiguous and require knowledge of common word use and grammar. This problem is now handled by deep learning transfer models like BERT.

\n\n

In addition to installing spaCy you also need the library neuralcoref. Only specific versions of spaCy and neuralcoref are compatible with each other. As of July 31, 2020 the following works to get dependencies and run the example for this section:

\n\n

pip uninstall spacy neuralcoref\npip install spacy==2.1.3\npython -m spacy download en\npip install neuralcoref==4.0.0\n./coref_example.hy \n

\n\n\n\n

Please note that version 2.1.3 of spaCy is older than the default version that pip installs. You might want to create a new Python virtual environment for this example or if you use Anaconda then use separate Anaconda environment.

\n\n

Listing of coref_nlp_lib.hy contains a wrapper for spaCy’s coreference model:

\n\n

 1 (import argparse os)\n 2 (import spacy neuralcoref)\n 3 \n 4 (setv nlp2 (spacy.load \"en\"))\n 5 (neuralcoref.add_to_pipe nlp2)\n 6 \n 7 (defn coref-nlp [some-text]\n 8   (setv doc (nlp2 some-text))\n 9   { \"corefs\" doc._.coref_resolved\n10     \"clusters\" doc._.coref_clusters\n11     \"scores\" doc._.coref_scores})\n

\n\n\n\n

Listing of coref_example.hy shows code to test the Hy spaCy and coreference wrapper:

\n\n

1 #!/usr/bin/env hy\n2 \n3 (import [coref-nlp-lib [coref-nlp]])\n4 \n5 ;; tests:\n6 (print (coref-nlp \"President George Bush went to Mexico and he had a very good meal\"\\\n7 ))\n8 (print (coref-nlp \"Lucy threw a ball to Bill and he caught it\"))\n

\n\n\n\n

The output will look like:

\n\n

 1 Marks-MacBook:nlp $ ./coref_example.hy \n 2 {'corefs': 'President George Bush went to Mexico and President George Bush had a ver\\\n 3 y good meal', 'clusters': [President George Bush: [President George Bush, he]], 'sco\\\n 4 res': {President George Bush: {President George Bush: 1.5810412168502808}, George Bu\\\n 5 sh: {George Bush: 4.11817741394043, President George Bush: -1.546141266822815}, Mexi\\\n 6 co: {Mexico: 1.4138349294662476, President George Bush: -4.650205612182617, George B\\\n 7 ush: -3.666614532470703}, he: {he: -0.5704692006111145, President George Bush: 9.385\\\n 8 97583770752, George Bush: -1.4178757667541504, Mexico: -3.6565260887145996}, a very \\\n 9 good meal: {a very good meal: 1.652894377708435, President George Bush: -2.554375886\\\n10 9171143, George Bush: -2.13267183303833, Mexico: -1.6889561414718628, he: -2.7667927\\\n11 742004395}}}\n12 \n13 {'corefs': 'Lucy threw a ball to Bill and Bill caught a ball', 'clusters': [a ball: \\\n14 [a ball, it], Bill: [Bill, he]], 'scores': {Lucy: {Lucy: 0.41820740699768066}, a bal\\\n15 l: {a ball: 1.8033190965652466, Lucy: -2.721518039703369}, Bill: {Bill: 1.5611814260\\\n16 482788, Lucy: -2.8222298622131348, a ball: -1.806389570236206}, he: {he: -0.57600766\\\n17 42036438, Lucy: 3.054243326187134, a ball: -1.818403720855713, Bill: 3.0774276256561\\\n18 28}, it: {it: -1.0269954204559326, Lucy: -3.4972281455993652, a ball: -0.31290221214\\\n19 294434, Bill: -2.5343685150146484, he: -3.6687228679656982}}}\n

\n\n\n\n

Anaphora resolution, also called coreference, refers to two or more words or phrases in an input text refer to the same noun. This analysis usually entails identifying which noun phrases that pronouns refer to.

\n\n

\nWrap-up

\n\n

I spent several years of development time during the period from 1984 through 2015 working on natural language processing technology and as a personal side project I sold commercial NLP libraries that I wrote on my own time in Ruby and Common Lisp. The state-of-the-art of Deep Learning enhanced NLP is very good and the open source spaCy library makes excellent use of both conventional NLP technology and pre-trained Deep Learning models. I no longer spend very much time writing my own NLP libraries and instead use spaCy.

\n\n

I urge you to read through the spaCy documentation because we covered just basic functionality here that we will also need in the later chapter on automatically generating data for Knowledge Graphs. After working through the interactive REPL sessions and the examples in this chapter, you should be able to translate any Python API example code to Hy.

\n\n\n

\nEntity Detection

\n\n

TBD

\n\n\n

\nText Generation

\n\n

TBD

\n\n\n

\nPart IV - Knowledge Representation Using Semantic Web Technologies

\n\n

TBD

\n\n\n

\nKnowledge Representation Using the Neo4J Graph Database

\n\n

TBD

\n\n

We will automatically generate data for Neo4J in the later chapter Knowledge Graph Creator and the following two figures show data generated in this later chapter:

\n\n\n

\"Part — Part of a Knowledge Graph shown in Neo4j web application console

\n\n\n

Here is a detail view:

\n\n\n

\n\n\n\n

\nLinked Data and the Semantic Web

\n\n

Tim Berners Lee, James Hendler, and Ora Lassila wrote in 2001 an article for Scientific American where they introduced the term Semantic Web. Here I do not capitalize semantic web and use the similar term linked data somewhat interchangeably with semantic web.

\n\n

I assume that you read the section RDF Data Using the “rdflib” Library in the last chapter.

\n\n

In the same way that the web allows links between related web pages, linked data supports linking associated data on the web together. I view linked data as a relatively simple way to specify relationships between data sources on the web while the semantic web has a much larger vision: the semantic web has the potential to be the entirety of human knowledge represented as data on the web in a form that software agents can work with to answer questions, perform research, and to infer new data from existing data.

\n\n

While the “web” describes information for human readers, the semantic web is meant to provide structured data for ingestion by software agents. This distinction will be clear as we compare WikiPedia, made for human readers, with DBPedia which uses the info boxes on WikiPedia topics to automatically extract RDF data describing WikiPedia topics. Let’s look at the WikiPedia topic for the town I live in, Sedona Arizona, and show how the info box on the English version of the WikiPedia topic page for Sedona https://en.wikipedia.org/wiki/Sedona,_Arizona maps to the DBPedia page http://dbpedia.org/page/Sedona,_Arizona. Please open both of these WikiPedia and DBPedia URIs in two browser tabs and keep them open for reference.

\n\n

I assume that the format of the WikiPedia page is familiar so let’s look at the DBPedia page for Sedona that in human readable form shows the RDF statements with Sedona Arizona as the subject. RDF is used to model and represent data. RDF is defined by three values so an instance of an RDF statement is called a triple with three parts:

\n\n

subject: a URI (also referred to as a “Resource”)
property: a URI (also referred to as a “Resource”)
value: a URI (also referred to as a “Resource”) or a literal value (like a string)

\n\n

The subject for each Sedona related triple is the above URI for the DBPedia human readable page. The subject and property references in an RDF triple will almost always be a URI that can ground an entity to information on the web. The human readable page for Sedona lists several properties and the values of these properties. One of the properties is “dbo:areaCode” where “dbo” is a name space reference (in this case for a DatatypeProperty).

\n\n

The following two figures show an abstract representation of linked data and then a sample of linked data with actual web URIs for resources and properties:

\n\n\n

\n\n\n\n

\"Concrete — Concrete example using RDF seen in last chapter showing the RDF representation with 2 Resources, 2 literal values, and 3 Properties

\n\n\n

We saw a SPARQL Query (SPARQL for RDF data is similar to SQL for relational database queries) in the last chapter. Let’s look at another example using the RDF in the last figure:

\n\n

        select ?v where {\n                           <http://markwatson.com/index.rdf#Sun_ONE>\n                           <http://www.ontoweb.org/ontology/1#booktitle>\n                           ?v\n                        }\n

\n\n\n\n

This query should return the result “Sun ONE Services - J2EE”. If you wanted to query for all URI resources that are books with the literal value of their titles, then you can use:

\n\n

        select ?s ?v where {  ?s\n                              <http://www.ontoweb.org/ontology/1#booktitle>\n                              ?v }\n

\n\n\n\n

Note that ?s and ?v are arbitrary query variable names, here standing for “subject” and “value”. I encourage you, dear reader, to use more descriptive variable names like:

\n\n

        select ?bookURI ?bookTitle where \n            { ?bookURI\n              <http://www.ontoweb.org/ontology/1#booktitle>\n              ?bookTitle }\n

\n\n\n\n

We will be diving a little deeper into RDF examples in the next chapter when we write a tool for generating RDF data from raw text input. For now I want you to understand the idea of RDF statements represented as triples, that web URIs represent things, properties, and sometimes values, and that URIs can be followed manually (often called “dereferencing”) to see what they reference in human readable form.

\n\n

\nUnderstanding the Resource Description Framework (RDF)

\n\n

Text data on the web has some structure in the form of HTML elements like headers, page titles, anchor links, etc. but this structure is too imprecise for general use by software agents. RDF is a method for encoding structured data in a more precise way.

\n\n

We used the RDF data on my web site in the last chapter to introduce the “plumbing” of using the rdflib Python library to access, manipulate, and query RDF data.

\n\n

\nResource Namespaces Provided in rdflib

\n\n

The following standard namespaces are predefined in rdflib:

\n\n

RDF https://www.w3.org/TR/rdf-syntax-grammar/\n
RDFS https://www.w3.org/TR/rdf-schema/\n
OWL http://www.w3.org/2002/07/owl#\n
XSD http://www.w3.org/2001/XMLSchema#\n
FOAF http://xmlns.com/foaf/0.1/\n
SKOS http://www.w3.org/2004/02/skos/core#\n
DOAP http://usefulinc.com/ns/doap#\n
DC http://purl.org/dc/elements/1.1/\n
DCTERMS http://purl.org/dc/terms/\n
VOID http://rdfs.org/ns/void#\n

\n\n

Let’s look into the Friend of a Friend (FOAF) namespace. Click on the above link for FOAF http://xmlns.com/foaf/0.1/ and find the definitions for the FOAF Core:

\n\n

 1     Agent\n 2     Person\n 3     name\n 4     title\n 5     img\n 6     depiction (depicts)\n 7     familyName\n 8     givenName\n 9     knows\n10     based_near\n11     age\n12     made (maker)\n13     primaryTopic (primaryTopicOf)\n14     Project\n15     Organization\n16     Group\n17     member\n18     Document\n19     Image\n

\n\n\n\n

and for the Social Web:

\n\n

 1 nick\n 2 mbox\n 3 homepage\n 4 weblog\n 5 openid\n 6 jabberID\n 7 mbox_sha1sum\n 8 interest\n 9 topic_interest\n10 topic (page)\n11 workplaceHomepage\n12 workInfoHomepage\n13 schoolHomepage\n14 publications\n15 currentProject\n16 pastProject\n17 account\n18 OnlineAccount\n19 accountName\n20 accountServiceHomepage\n21 PersonalProfileDocument\n22 tipjar\n23 sha1\n24 thumbnail\n25 logo\n

\n\n\n\n

You now have seen a few common Schemas for RDF data. Another Schema that is widely used for annotating web sites, that we won’t need for our examples here, is schema.org. Let’s now use a Hy REPL session to explore namespaces and programatically create RDF using rdflib:

\n\n

 1 $ python\n 2 Python 3.8.3 (default, May 19 2020, 13:54:14) \n 3 [Clang 10.0.0 ] :: Anaconda, Inc. on darwin\n 4 >>> from rdflib.namespace import FOAF\n 5 >>> FOAF\n 6 rdf.namespace.ClosedNamespace('http://xmlns.com/foaf/0.1/')\n 7 >>> FOAF.name\n 8 rdflib.term.URIRef('http://xmlns.com/foaf/0.1/name')\n 9 >>> FOAF.title\n10 rdflib.term.URIRef('http://xmlns.com/foaf/0.1/title')\n11 >>> import rdflib\n12 >>> graph = rdflib.Graph()\n13 >>> mark = rdflib.BNode()\n14 >>> graph.bind('foaf', FOAF)\n15 >>> from rdflib import RDF\n16 >>> graph.add([mark, RDF.type, FOAF.Person])\n17 >>> graph.add([mark, FOAF.nick, rdflib.Literal('Mark', lang='en')])\n18 >>> graph.add([mark, FOAF.name, rdflib.Literal('Mark Watson', lang='en')])\n19 >>> for node in graph:\n20 ...   print(node)\n21 ... \n22 (rdflib.term.BNode('N37abd8b389a54d9bae7f0eb1a1b557a0'), rdflib.term.URIRef('http://\\\n23 www.w3.org/1999/02/22-rdf-syntax-ns#type'), rdflib.term.URIRef('http://xmlns.com/foa\\\n24 f/0.1/Person'))\n25 (rdflib.term.BNode('N37abd8b389a54d9bae7f0eb1a1b557a0'), rdflib.term.URIRef('http://\\\n26 xmlns.com/foaf/0.1/name'), rdflib.term.Literal('Mark Watson', lang='en'))\n27 (rdflib.term.BNode('N37abd8b389a54d9bae7f0eb1a1b557a0'), rdflib.term.URIRef('http://\\\n28 xmlns.com/foaf/0.1/nick'), rdflib.term.Literal('Mark', lang='en'))\n29 >>> graph.serialize(format='pretty-xml')\n30 b'<?xml version=\"1.0\" encoding=\"utf-8\"?>\\n<rdf:RDF\\n  xmlns:rdf=\"http://www.w3.org/1\\\n31 999/02/22-rdf-syntax-ns#\"\\n  xmlns:foaf=\"http://xmlns.com/foaf/0.1/\"\\n>\\n  <foaf:Per\\\n32 son rdf:nodeID=\"N37abd8b389a54d9bae7f0eb1a1b557a0\">\\n    <foaf:name xml:lang=\"en\">Ma\\\n33 rk Watson</foaf:name>\\n    <foaf:nick xml:lang=\"en\">Mark</foaf:nick>\\n  </foaf:Perso\\\n34 n>\\n</rdf:RDF>\\n'\n35 b'<?xml version=\"1.0\" encoding=\"utf-8\"?>\n36 >>> graph.serialize(format='pretty-xml')\n37 <rdf:RDF\n38     xmlns:foaf=\"http://xmlns.com/foaf/0.1/\"\n39     xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"\n40 >\n41   <foaf:Person rdf:nodeID=\"N21c7fa7385b545eb8a7e3821b75b9cb5\">\n42     <foaf:name xml:lang=\"en\">Mark Watson</foaf:name>\n43     <foaf:nick xml:lang=\"en\">Mark</foaf:nick>\n44   </foaf:Person>\n45 </rdf:RDF>'\n46 >>> graph.serialize(format='turtle')\n47 => (graph.serialize :format \"turtle\")\n48 b'@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n49 \n50 [] a foaf:Person ;\n51      foaf:name \"Mark Watson\"@en ;\n52      foaf:nick \"Mark\"@en .'\n53 >>> graph.serialize(format='nt')\n54 b'_:N37abd8b389a54d9bae7f0eb1a1b557a0\n55    <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>\n56    <http://xmlns.com/foaf/0.1/Person> .\n57 _:N37abd8b389a54d9bae7f0eb1a1b557a0 <http://xmlns.com/foaf/0.1/name> \"Mark Watson\"@e\\\n58 n .\n59 _:N37abd8b389a54d9bae7f0eb1a1b557a0 <http://xmlns.com/foaf/0.1/nick> \"Mark\"@en .\n60 >>> \n

\n\n\n\n

\nUnderstanding the SPARQL Query Language

\n\n

For the purposes of the material in this book, the two sample SPARQL queries here and in the last chapter are sufficient for you to get started using rdflib with arbitrary RDF data sources and simple queries.

\n\n

The Apache Foundation has a good introduction to SPARQL that I refer you to for more information.

\n\n

\nUsing the Python rdflib Library

\n\n

I hope that I have provided you with enough motivation to explore RDF data sources and consider the use of linked data/semantic web technologies for your projects.

\n\n

You can install using the source code for rdflib or using:

\n\n

pip install rdflib\n

\n\n\n\n

If I depend on a library, regardless of the programming language, I like to keep an up-to-date copy of the source code ready at hand. There is sometimes no substitute for having library code available to read.

\n\n

In the next chapter we will use natural language processing to extract structured information from raw text and automatically generate RDF data.

\n\n\n

\nKnowledge Graph Creator

\n\n

TBD: CONVERT EXAMPLES FROM Hylang to PYTHON!!

\n\n

A Knowledge Graph, that I often abbreviate as KG, is a graph database using a schema to define types (both objects and relationships between objects) and properties that link property values to objects. The term “Knowledge Graph” is both a general term and also sometimes refers to the specific Knowledge Graph used at Google which I worked with while working there in 2013. Here, we use KG to reference the general technology of storing knowledge in graph databases.

\n\n

The application we develop here, the Knowledge Graph Creator (which I often refer to as KGCreator) is a utility that I use to generate small Knowledge Graphs from input text.

\n\n

Knowledge engineering and knowledge representation are disciplines that started in the 1980s and are still both current research topics and used in industry. I view linked data, the semantic web, and KGs as extensions of this earlier work.

\n\n

We base our work here on RDF. There is a general type of KGs that are also widely used in industry and that we will not cover here: property graphs, as used in Neo4J. Property graphs are general graphs that place no restrictions on the number of links a graph node may have and allow general data structures to be stored as node data and for the property links between nodes. Property links can have attributes, like nodes in the graph.

\n\n

Semantic web data as represented by subject/property/value RDF triples are more constrained than property graphs but support powerful logic inferencing to better use data that is implicit in a graph but not explicitly stated (i.e., data is more easily inferred).

\n\n

We covered RDF data in some detail in the last chapter. Here we will implement a toolset for converting unstructured text into RDF data using a few schema definitions from schema.org. I believe in both the RDF and the general graph database approaches but here we will just use RDF.

\n\n

Historically Knowledge Graphs used semantic web technology like Resource Description Framework (RDF) and Web Ontology Language (OWL). I wrote two books in 2010 on semantic web technologies and you can get free PDFs for the Common Lisp version (code is here) and the Java/Clojure/Scala version (code is here). These free books might interest you after working through the material in this chapter.

\n\n

I have an ongoing personal research project for creating knowledge graphs from various data sources. You can read more at my KGCreator web site. I have simplified versions of my KGCreator software implemented in both my Haskell Book and in my most recent Common Lisp book. The example here is similar to my Common Lisp implementation, except that it is implemented in the Hy language and I only support generating RDF. The examples in my Haskell and Common Lisp books also generate data for the Neo4J graph database.

\n\n

What is a KG? It is a modern way to organize and access structured data and integrate data and metadata with other automated systems.

\n\n

A Knowledge Graph is different from just a graph database containing graph data. The difference is that a KG will in general use Schemas, Taxonomy’s and Ontology’s that define the allowed types and structure of data and allowed relationships.

\n\n

There is also an executable aspect of KGs since their primary use may be to support other systems in an organization.

\n\n

\nRecommended Industrial Use of Knowledge Graphs

\n\n

Who needs a KG? How do you get started?

\n\n

If people in your organization are spending much time doing general web search, it might be a signal that you should maintain your organization’s curated knowledge in a human searchable and software accessible way. A possible application is an internal search engine that mixes public web search APIs with search for knowledge used internally inside your organization.

\n\n

Here are a few use cases:

\n\n

At Google we used their Knowledge Graph for researching new internal systems that were built on their standard Knowledge Graph, with new schemas and data added.
Digital transformations: start by using a KG to hold metadata for current data in already existing databases. A KG of metadata can provide you with a virtual data lake. It is common to build a large data lake and then have staff not be able to find data. Don’t try to do everything at once.
Capture and preserve senior human expertise. The act of building an Ontology for in-house knowledge helps to understand how to organize data and provides people with a common vocabulary to discuss and model business processes.
KYC (Know Your Customer) applications using data from many diverse data sources.
Take advantage of expertise in a domain (e.g., healthcare or financial services) to build a Taxonomy and Ontology to use to organize available data. For most domains, there are standard existing Schemas, Taxonomy’s and Ontology’s that can be identified and used as-is or extended for your organization.

\n\n

To get started:

\n\n

Start small with just one use case.
Design a Schema that identifies object types and relationships
Write some acceptance test cases that you want a prototype to be able to serve as a baseline to develop against.
Avoid having too many stakeholders in early prototype projects â€” try to choose stakeholders based on potential stakeholders’ initial enthusiasm.

\n\n

A good way to start is to identify a single problem, determine the best data sources to use, define an Ontology that is just sufficient to solve the current problem and build a prototype “vertical slice” application. Lessons learned with a quick prototype will inform you on what was valuable and what to put effort into when expanding your KG. Start small and don’t try to build a huge system without taking many small development and evaluation steps.

\n\n

What about KGs for small organizations? Small companies have less development resources but starting small and implementing a system that models the key data relationships, customer relationships, etc., does not require excessive resources. Just capturing where data comes from and who is responsible for maintaining important data sources can be valuable.

\n\n

What about KGs for individuals? Given the effort involved in building custom KGs, one possible individual use case is developing KGs for commercial sale.

\n\n

The application that we develop next is one way to quickly bootstrap a new KG by populating it with automatically generated RDF than can be manually curated by removing statements and adding new statements as appropriate.

\n\n

\nDesign of KGCreator Application

\n\n

The example application developed here processes input text files in the sub-directory test_data. For each file with the extension .txt in test_data, there should be a matching file with the extension .meta that contains the origin URI for the corresponding text file. The git repository for this book has a few files in test_data that you can experiment with or replace with your own data:

\n\n

$ ls test_data \ntest1.meta test1.txt test2.meta test2.txt test3.meta test3.txt\n

\n\n\n\n

The *.txt files contain plain text for analysis and the *.meta files contain the original web source URI for the corresponding *.txt files. Using the spaCy library and Python/Hy’s standard libraries for file access, the KGCreator is simple to implement. Here is the overall design of this example:

\n\n\n

\"Overview — Overview of the Knowledge Graph Creator script

\n\n\n

We will develop two versions of the Knowledge Graph Creator. The first generates RDF that uses string values for the object part of generated RDF statements. The second implementation attempts to resolve these string values to DBPedia URIs.

\n\n

Using only the spaCy NLP library that we used earlier and the built in Hy/Python libraries, this first example (uses strings a object values) is implemented in just 58 lines of Hy code that is seen in the following three code listings:

\n\n

 1 #!/usr/bin/env hy\n 2 \n 3 (import [os [scandir]])\n 4 (import [os.path [splitext exists]])\n 5 (import spacy)\n 6 \n 7 (setv nlp-model (spacy.load \"en\"))\n 8 \n 9 (defn find-entities-in-text [some-text]\n10   (defn clean [s]\n11     (.strip (.replace s \"\\n\" \" \")))\n12   (setv doc (nlp-model some-text))\n13   (map list (lfor entity doc.ents [(clean entity.text) entity.label_])))\n

\n\n\n\n

In lines 3 and 4 we import three standard Python utilities we need for finding all files in a directory, checking to see if a file exists, and splitting text into tokens. In line 7 we load the English language spaCy model and save the value of the model in the variable nlp-model. The function find-entities-in-text uses the spaCy English language model to find entities like organizations, people, etc., in text and cleans entity names by removing new line characters and other unnecessary white space (nested function clean in lines 10 and 11). We can run a test in a REPL:

\n\n

=> (list (find-entities-in-text \"John Smith went to Los Angeles to work at IBM\"))\n[['John Smith', 'PERSON'], ['Los Angeles', 'GPE'], ['IBM', 'ORG']]\n

\n\n\n\n

The function find-entities-in-text returns a map object so I wrapped the results in a list to print out the entities in the test sentence. The entity types used by spaCy were defined in an earlier chapter, here we just use the entity types defined in lines 21-26 in the following listing:

\n\n

14 (defn data2Rdf [meta-data entities fout]\n15   (for [[value abbreviation] entities]\n16     (if (in abbreviation e2umap)\n17       (.write fout (+ \"<\" meta-data \">\\t\" (get e2umap abbreviation) \"\\t\" \"\\\"\"\n18                        value \"\\\"\" \" .\\n\")))))\n19 \n20 (setv e2umap {\n21   \"ORG\" \"<https://schema.org/Organization>\"\n22   \"LOC\" \"<https://schema.org/location>\"\n23   \"GPE\" \"<https://schema.org/location>\"\n24   \"NORP\" \"<https://schema.org/nationality>\"\n25   \"PRODUCT\" \"<https://schema.org/Product>\"\n26   \"PERSON\" \"<https://schema.org/Person>\"})\n

\n\n\n\n

In lines 28-39 we open an output file for writing generated RDF data and loop through all text files in the input directory and call the function process-file for each text + meta file pair in the input directory:

\n\n

28 (defn process-directory [directory-name output-rdf]\n29   (with [frdf (open output-rdf \"w\")]\n30     (with [entries (scandir directory-name)]\n31       (for [entry entries]\n32         (setv [_ file-extension] (splitext entry.name))\n33         (if (= file-extension \".txt\")\n34             (do\n35               (setv check-file-name (+ (cut entry.path 0 -4) \".meta\"))\n36               (if (exists check-file-name)\n37                   (process-file entry.path check-file-name frdf)\n38                   (print \"Warning: no .meta file for\" entry.path\n39                          \"in directory\" directory-name))))))))\n

\n\n\n\n

40 (defn process-file [txt-path meta-path frdf]\n41   \n42   (defn read-data [text-path meta-path]\n43     (with [f (open text-path)] (setv t1 (.read f)))\n44     (with [f (open meta-path)] (setv t2 (.read f)))\n45     [t1 t2])\n46   \n47   (defn modify-entity-names [ename]\n48     (.replace ename \"the \" \"\"))\n49   \n50   (setv [txt meta] (read-data txt-path meta-path))\n51   (setv entities (find-entities-in-text txt))\n52   (setv entities ;; only operate on a few entity types\n53         (lfor [e t] entities\n54               :if (in t [\"NORP\" \"ORG\" \"PRODUCT\" \"GPE\" \"PERSON\" \"LOC\"])\n55               [(modify-entity-names e) t]))\n56   (data2Rdf meta entities frdf))\n57 \n58 (process-directory \"test_data\" \"output.rdf\")\n

\n\n\n\n

We will look at generated output, problems with it, and how to fix these problems in the next section.

\n\n

\nProblems with using Literal Values in RDF

\n\n

Using the Hy script in the last section, let’s look at some of the generated RDF for the text files in the input test directory (most output is not shown). In each triple the first item, the subject, is the URI of the data source, the second item in each statement is a URI representing a relationship (or property), and the third item is a literal string value:

\n\n

<https://newsshop.com/may/a1023.html>\n  <https://schema.org/nationality>\t\"Portuguese\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\t\"Banco Espirito Santo SA\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Person>\t      \"John Evans\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\t\"Banco Espirito\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\t\"The Wall Street Journal\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\t\"IBM\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/location>\t\"Canada\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\t\"Australian Broadcasting Corporation\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Person>\t\"Frank Smith\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\t\"Australian Writers Guild\" .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\t\"American University\" .\n<https://localnews.com/june/z902.html>\n  <https://schema.org/Organization>\t\"The Wall Street Journal\" .\n<https://localnews.com/june/z902.html>\n  <https://schema.org/location>\t\"Mexico\" .\n<https://localnews.com/june/z902.html>\n  <https://schema.org/location>\t\"Canada\" .\n<https://localnews.com/june/z902.html>\n  <https://schema.org/Person>\t\"Bill Clinton\" .\n<https://localnews.com/june/z902.html>\n  <https://schema.org/Organization>\t\"IBM\" .\n<https://localnews.com/june/z902.html>\n  <https://schema.org/Organization>\t\"Microsoft\" .\n<https://abcnews.go.com/US/violent-long-lasting-tornadoes-threaten-oklahoma-texas/st\\\nory?id=63146361>\n  <https://schema.org/Person>\t\"Jane Deerborn\" .\n<https://abcnews.go.com/US/violent-long-lasting-tornadoes-threaten-oklahoma-texas/st\\\nory?id=63146361>\n  <https://schema.org/location>\t\"Texas\" .\n

\n\n\n\n

Let’s visualize the results in a bash shell:

\n\n

$ git clone https://github.com/fatestigma/ontology-visualization\n$ cd ontology-visualization\n$ chmod +x ontology_viz.py\n$ ./ontology_viz.py -o test.dot output.rdf  -O ontology.ttl\n$ # copy the file output.rdf from examples repo directory hy-lisp-python/kgcreator\n$ dot -Tpng -o test.png test.dot\n$ open test.png\n

\n\n\n\n

Edited to fit on the page, the output looks like:

\n\n\n

\n\n\n\n

\n\n\n\n

\n\n\n

Because we used literal values, notice how for example the node for the entity IBM is not shared and thus a software agent using this RDF data cannot, for example, infer relationships between two news sources that both have articles about IBM. We will work on a solution to this problem in the next section.

\n\n

\nRevisiting This Example Using URIs Instead of Literal Values

\n\n

Note that in the figure in the previous section that nodes for literal values (e.g., for “IBM”) are not shared. In this section we will copy the file kgcreator.hy to kgcreator_uri.hy add a few additions to map string literal values for entity names to http://dbpedia.org URIs by individually searching Google using the pattern “DBPedia ‘entity name’” and defining a new map v2umap for mapping literal values to DBPedia URIs.

\n\n

Note: In a production system (not a book example), I would use https://www.wikidata.org database download to download all of WikiData (which includes DBPedia data) and use a fuzzy text matching to find WikiData URIs for string literals. The compressed WikiData JSON data file is about 50 GB. Here we will manually find DBPedia for entity names that are in the example data.

\n\n

In kgcreator_uri.hy we add a map v2umap for selected entity literal names to DBPedia URIs that I manually created using a web search on the DBPedia domain:

\n\n

(setv v2umap { ;; object literal value to URI mapping\n  \"IBM\" \"<http://dbpedia.org/page/IBM>\"\n  \"The Wall Street Journal\" \"<http://dbpedia.org/page/The_Wall_Street_Journal>\"\n  \"Banco Espirito\" \"<http://dbpedia.org/page/Banco_Esp%C3%ADrito_Santo>\"\n  \"Australian Broadcasting Corporation\"\n  \"http://dbpedia.org/page/Australian_Broadcasting_Corporation\"\n  \"Australian Writers Guild\"\n  \"http://dbpedia.org/page/Australian_Broadcasting_Corporation\"\n  \"Microsoft\" \"http://dbpedia.org/page/Microsoft\"})\n

\n\n\n\n

We also make a change in the function data2Rdf to use the map v2umap:

\n\n

(defn data2Rdf [meta-data entities fout]\n  (for [[value abbreviation] entities]\n    (setv a-literal (+ \"\\\"\" value \"\\\"\"))\n    (if (in value v2umap) (setv a-literal (get v2umap value)))\n    (if (in abbreviation e2umap)\n      (.write fout (+ \"<\" meta-data \">\\t\" (get e2umap abbreviation)\n                      \"\\t\" a-literal \" .\\n\")))))\n

\n\n\n\n

Here is some of the generated RDF that has changed:

\n\n

<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\n  <http://dbpedia.org/page/IBM> .\n<https://newsshop.com/may/a1023.html>\n  <https://schema.org/Organization>\n  <http://dbpedia.org/page/Banco_Esp%C3%ADrito_Santo> .\n

\n\n\n\n

Now when we visualize generated RDF, we share nodes for The Wallstreet Journal and IBM:

\n\n\n

While literal values sometimes are useful in generated RDF, using literals for the values in RDF triples prevents types of queries and inference that can be performed on the data.

\n\n

\nWrap-up

\n\n

In the field of Artificial Intelligence there are two topics that get me the most excited and I have been fortunate to be paid to work on both: Deep Learning and Knowledge Graphs. Here we have just touched the surface for creating data for Knowledge Graphs but I hope that between this chapter and the material on RDF in the chapter Datastores that you have enough information and experience playing with the examples to get started prototyping a Knowledge Graph in your organizartion. My advice is to “start small” by picking a problem that your organization has that can be solved by not moving data around, but rather, by creating a custom Knowledge Graph for metadata for existing information in your organization.

\n\n\n

\nKnowledge Graph Navigator

\n\n

TBD: CONVERT EXAMPLES FROM Hylang to Python

\n\n

The Knowledge Graph Navigator (which I will often refer to as KGN) is a tool for processing a set of entity names and automatically exploring the public Knowledge Graph DBPedia using SPARQL queries. I wrote KGN in Common Lisp for my own use to automate some things I used to do manually when exploring Knowledge Graphs, and later thought that KGN might be useful also for educational purposes. KGN uses NLP code developed in earlier chapters and we will reuse that code with a short review of using the APIs.

\n\n

Please note that the example is a simplified version that I first wrote in Common Lisp and is also an example in my book Loving Common Lisp, or the Savvy Programmer’s Secret Weapon that you can read for free online. If you are interested you can see screen shots of the Common Lisp version here.

\n\n

The following two screen shots show the text based user interface for this example. This example application asks the user for a list of entity names and uses SPARQL queries to discover potential matches in DBPedia. We use the python library PyInquirer for requesting entity names and then to show the user a list of matches from DBPedia. The following screen shot shows these steps:

\n\n\n

\"Initial — Initial user interaction with Knowledge Graph Navigator example

\n\n\n

To select the entities of interest, the user uses a space character to select or deselect an entity and the return (or enter) key to accept the list selections.

\n\n

After the user selects entities from the list, the list disappears. The next screen shot shows the output from this example after the user finishes selecting entities of interest:

\n\n\n

The code for this application is in the directory kgn. You will need to install the following Python library that supports console/text user interfaces:

\n\n

pip install PyInquirer\n

\n\n\n\n

You will also need the spacy library and language model that we used in the earlier chapter on natural language processing. If you have not already done so, install these requirements:

\n\n

pip install spacy\npython -m spacy download en_core_web_sm\n

\n\n\n\n

After listing the generated SPARQL for finding information for the entities in the query, KGN searches for relationships between these entities. These discovered relationships can be seen at the end of the last screen shot. Please note that this step makes SPARQL queries on O(n^2) where n is the number of entities. Local caching of SPARQL queries to DBPedia helps make processing many entities possible.

\n\n

Every time KGN makes a SPARQL query web service call to DBPedia the query and response are cached in a SQLite database in ~/.kgn_hy_cache.db which can greatly speed up the program, especially in development mode when testing a set of queries. This caching also takes some load off of the public DBPedia endpoint, which is a polite thing to do.

\n\n

\nReview of NLP Utilities Used in Application

\n\n

We covered NLP in a previous chapter, so the following is just a quick review. The NLP code we use is near the top of the file kgn.hy:

\n\n

(import spacy)\n\n(setv nlp-model (spacy.load \"en\"))\n\n(defn entities-in-text [s]\n  (setv doc (nlp-model s))\n  (setv ret {})\n  (for\n    [[ename etype] (lfor entity doc.ents [entity.text entity.label_])]   \n    (if (in etype ret)\n        (setv (get ret etype) (+ (get ret etype) [ename]))\n        (assoc ret etype [ename])))\n  ret)\n

\n\n\n\n

Here is an example use of this function:

\n\n

=> (kgn.entities-in-text \"Bill Gates, Microsoft, Seattle\")\n{'PERSON': ['Bill Gates'], 'ORG': ['Microsoft'], 'GPE': ['Seattle']}\n

\n\n\n\n

The entity type “GPE” indicates that the entity is some type of location.

\n\n

\nDeveloping Low-Level Caching SPARQL Utilities

\n\n

While developing KGN and also using it as an end user, many SPARQL queries to DBPedia contain repeated entity names so it makes sense to write a caching layer. We use a SQLite database “~/.kgn_hy_cache.db” to store queries and responses. We covered using SQLite in some detail in the chapter on datastores.

\n\n

The caching layer is implemented in the file cache.hy:

\n\n

 1 (import [sqlite3 [connect version Error ]])\n 2 (import json)\n 3 \n 4 (setv *db-path* \"kgn_hy_cache.db\")\n 5 \n 6 (defn create-db []\n 7   (try\n 8     (setv conn (connect *db-path*))\n 9     (print version)\n10     (setv cur (conn.cursor))\n11     (cur.execute \"CREATE TABLE dbpedia (query string  PRIMARY KEY ASC, data json)\")\n12     (conn.close)\n13     (except [e Exception] (print e))))\n14 \n15 (defn save-query-results-dbpedia [query result]\n16   (try\n17     (setv conn (connect *db-path*))\n18     (setv cur (conn.cursor))\n19     (cur.execute \"insert into dbpedia (query, data) values (?, ?)\" \n20                  [query (json.dumps result)])\n21     (conn.commit)\n22     (conn.close)\n23     (except [e Exception] (print e))))\n24  \n25 (defn fetch-result-dbpedia [query]\n26   (setv results [])\n27   (setv conn (connect *db-path*))\n28   (setv cur (conn.cursor))\n29   (cur.execute \"select data from dbpedia where query = ? limit 1\" [query])\n30   (setv d (cur.fetchall))\n31   (if (> (len d) 0)\n32       (setv results (json.loads (first (first d)))))\n33   (conn.close)\n34   results)\n35  \n36 (create-db)\n

\n\n\n\n

Here we store structured data from SPARQL queries as JSON data serialized as string values.

\n\n

\nSPARQL Utilities

\n\n

We will use the caching code from the last section and also the standard Python library requests to access the DBPedia servers. The following code is found in the file sparql.hy and also provides support for using both DBPedia and WikiData. We only use DBPedia in this chapter but when you start incorporating SPARQL queries into applications that you write, you will also probably want to use WikiData.

\n\n

The function do-query-helper contains generic code for SPARQL queries and is used in functions wikidata-sparql and dbpedia-sparql:

\n\n

(import json)\n(import requests)\n(require [hy.contrib.walk [let]])\n\n(import [cache [fetch-result-dbpedia save-query-results-dbpedia]])\n\n(setv wikidata-endpoint \"https://query.wikidata.org/bigdata/namespace/wdq/sparql\")\n(setv dbpedia-endpoint \"https://dbpedia.org/sparql\")\n\n(defn do-query-helper [endpoint query]\n  ;; check cache:\n  (setv cached-results (fetch-result-dbpedia query))\n  (if (> (len cached-results) 0)\n      (let ()\n        (print \"Using cached query results\")\n        (eval cached-results))\n      (let ()\n        ;; Construct a request\n        (setv params { \"query\" query \"format\" \"json\"})\n        \n        ;; Call the API\n        (setv response (requests.get endpoint :params params))\n        \n        (setv json-data (response.json))\n        \n        (setv vars (get (get json-data \"head\") \"vars\"))\n        \n        (setv results (get json-data \"results\"))\n        \n        (if (in \"bindings\" results)\n            (let [bindings (get results \"bindings\")\n                  qr\n                  (lfor binding bindings\n                        (lfor var vars\n                              [var (get (get binding var) \"value\")]))]\n              (save-query-results-dbpedia query qr)\n              qr)\n            []))))\n\n(defn wikidata-sparql [query]\n  (do-query-helper wikidata-endpoint query))\n\n(defn dbpedia-sparql [query]\n  (do-query-helper dbpedia-endpoint query))\n

\n\n\n\n

Here is an example query (manually formatted for page width):

\n\n

$ hy\nhy 0.18.0 using CPython(default) 3.7.4 on Darwin\n=> (import sparql)\ntable dbpedia already exists\n=> (sparql.dbpedia-sparql\n     \"select ?s ?p ?o { ?s ?p ?o } limit 1\")\n[[['s', 'http://www.openlinksw.com/virtrdf-data-formats#default-iid'],\n  ['p', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'],\n  ['o', 'http://www.openlinksw.com/schemas/virtrdf#QuadMapFormat']]]\n=> \n

\n\n\n\n

This is a wild-card SPARQL query that will match any of the 9.5 billion RDF triples in DBPedia and return just one result.

\n\n

This caching layer greatly speeds up my own personal use of KGN. Without caching, queries that contain many entity references simply take too long to run.

\n\n

\nUtilities to Colorize SPARQL and Generated Output

\n\n

When I first had the basic functionality of KGN working, I was disappointed by how the application looked as normal text. Every editor and IDE I use colorizes text in an appropriate way so I used standard ANSI terminal escape sequences to implement color hilting SPARQL queries.

\n\n

The code in the following listing is in the file colorize.hy.

\n\n

(require [hy.contrib.walk [let]])\n(import [io [StringIO]])\n\n;; Utilities to add ANSI terminal escape sequences to colorize text.\n;; note: the following 5 functions return string values that then need to\n;;       be printed.\n\n(defn blue [s] (.format \"{}{}{}\" \"\\033[94m\" s \"\\033[0m\"))\n(defn red [s] (.format \"{}{}{}\" \"\\033[91m\" s \"\\033[0m\"))\n(defn green [s] (.format \"{}{}{}\" \"\\033[92m\" s \"\\033[0m\"))\n(defn pink [s] (.format \"{}{}{}\" \"\\033[95m\" s \"\\033[0m\"))\n(defn bold [s] (.format \"{}{}{}\" \"\\033[1m\" s \"\\033[0m\"))\n\n(defn tokenize-keep-uris [s]\n  (.split s))\n\n(defn colorize-sparql [s]\n  (let [tokens\n        (tokenize-keep-uris\n          (.replace (.replace (.replace s \"{\" \" { \") \"}\" \" } \") \".\" \" . \"))\n        ret (StringIO)] ;; ret is an output stream for a string buffer\n    (for [token tokens]\n      (if (> (len token) 0)\n          (if (= (get token 0) \"?\")\n              (.write ret (red token))\n              (if (in\n                    token\n                    [\"where\" \"select\" \"distinct\" \"option\" \"filter\"\n                     \"FILTER\" \"OPTION\" \"DISTINCT\" \"SELECT\" \"WHERE\"])\n                  (.write ret (blue token))\n                  (if (= (get token 0) \"<\")\n                      (.write ret (bold token))\n                      (.write ret token)))))\n      (if (not (= token \"?\"))\n          (.write ret \" \")))\n    (.seek ret 0)\n    (.read ret)))\n

\n\n\n\n

You have seen colorized SPARQL in the two screen shots at the beginning of this chapter.

\n\n

\nText Utilities for Queries and Results

\n\n

The application low level utility functions are in the file kgn-utils.hy. The function dbpedia-get-entities-by-name requires two arguments:

\n\n

The name of an entity to search for.
A URI representing the entity type that we are looking for.

\n\n

We embed a SPARQL query that has placeholders for the entity name and type. The filter expression specifies that we only want triple results with comment values in the English language by using (lang(?comment) = ‘en’):

\n\n

 1 #!/usr/bin/env hy\n 2 \n 3 (import [sparql [dbpedia-sparql]])\n 4 (import [colorize [colorize-sparql]])\n 5 \n 6 (import [pprint [pprint]])\n 7 (require [hy.contrib.walk [let]])\n 8 \n 9 (defn dbpedia-get-entities-by-name [name dbpedia-type]\n10   (let [sparql\n11         (.format \"select distinct ?s ?comment {{ ?s ?p \\\"{}\\\"@en . ?s <http://www.w3\\\n12 .org/2000/01/rdf-schema#comment>  ?comment  . FILTER  (lang(?comment) = 'en') . ?s <\\\n13 http://www.w3.org/1999/02/22-rdf-syntax-ns#type> {} . }} limit 15\" name dbpedia-type\\\n14 )]\n15     (print \"Generated SPARQL to get DBPedia entity URIs from a name:\")\n16     (print (colorize-sparql sparql))\n17     (dbpedia-sparql sparql)))\n

\n\n\n\n

Here is an example:

\n\n\n

\"Getting — Getting entities by name with colorized SPARL query script

\n\n\n

\nFinishing the Main Function for KGN

\n\n

We already looked at the NLP code near the beginning of the file kgn.hy. Let’s look at the remainder of the implementation.

\n\n

We need a dictionary (or hash table) to convert spaCy entity type names to DBPedia type URIs:

\n\n

1 (setv entity-type-to-type-uri\n2       {\"PERSON\" \"<http://dbpedia.org/ontology/Person>\"\n3        \"GPE\" \"<http://dbpedia.org/ontology/Place>\"\n4        \"ORG\" \"<http://dbpedia.org/ontology/Organisation>\"\n5        })\n

\n\n\n\n

When we get entity results from DBPedia, the comments describing entities can be a few paragraphs of text. We want to shorten the comments so they fit in a single line of the entity selection list that we have seen earlier. The following code defines a comment shortening function and also a global variable that we will use to store the entity URIs for each shortened comment:

\n\n

1 (setv short-comment-to-uri {})\n2 \n3 (defn shorten-comment [comment uri]\n4   (setv sc (+ (cut comment 0 70) \"...\"))\n5   (assoc short-comment-to-uri sc uri)\n6   sc)\n

\n\n\n\n

In line 5, we use the function assoc to add a key and value pair to an existing dictionary short-comment-to-uri.

\n\n

Finally, let’s look at the main application loop. In line 4 we are using the function get-query (defined in file textui.hy) to get a list of entity names from the user. In line 7 we use the function entities-in-text that we saw earlier to map text to entity types and names. In the nested loops in lines 13-26 we build one line descriptions of people, place, and organizations that we will use to show the user a menu for selecting entities found in DBPedia from the original query. We are giving the use a chance to select only the discovered entities that they are interested in.

\n\n

In lines 33-35 we are converting the shortened comment strings the user selected back to DBPedia entity URIs. Finally in line 36 we use the function entity-results->relationship-links to find relationships between the user selected entities.

\n\n

 1 (defn kgn []\n 2   (while\n 3     True\n 4     (let [query (get-query)\n 5           emap {}]\n 6       (if (or (= query \"quit\") (= query \"q\"))\n 7           (break))\n 8       (setv elist (entities-in-text query))\n 9       (setv people-found-on-dbpedia [])\n10       (setv places-found-on-dbpedia [])\n11       (setv organizations-found-on-dbpedia [])\n12       (global short-comment-to-uri)\n13       (setv short-comment-to-uri {})\n14       (for [key elist]\n15         (setv type-uri (get entity-type-to-type-uri key))\n16         (for [name (get elist key)]\n17           (setv dbp (dbpedia-get-entities-by-name name type-uri))\n18           (for [d dbp]\n19             (setv short-comment (shorten-comment (second (second d)) \n20             (second (first d))))\n21             (if (= key \"PERSON\")\n22                 (.extend people-found-on-dbpedia [(+ name  \" || \" short-comment)]))\n23             (if (= key \"GPE\")\n24                 (.extend places-found-on-dbpedia [(+ name  \" || \" short-comment)]))\n25             (if (= key \"ORG\")\n26                 (.extend organizations-found-on-dbpedia \n27                 [(+ name  \" || \" short-comment)])))))\n28       (setv user-selected-entities\n29             (select-entities\n30               people-found-on-dbpedia\n31               places-found-on-dbpedia\n32               organizations-found-on-dbpedia))\n33       (setv uri-list [])\n34       (for [entity (get user-selected-entities \"entities\")]\n35         (setv short-comment (cut entity (+ 4 (.index entity \" || \"))))\n36         (.extend uri-list [(get short-comment-to-uri short-comment)]))\n37       (setv relation-data (entity-results->relationship-links uri-list))\n38       (print \"\\nDiscovered relationship links:\")\n39       (pprint relation-data))))\n

\n\n\n\n

If you have not already done so, I hope you experiment running this example application. The first time you specify an entity name expect some delay while DBPedia is accessed. Thereafter the cache will make the application more responsive when you use the same name again in a different query.

\n\n

\nWrap-up

\n\n

If you enjoyed running and experimenting with this example and want to modify it for your own projects then I hope that I provided a sufficient road map for you to do so.

\n\n

I got the idea for the KGN application because I was spending quite a bit of time manually setting up SPARQL queries for DBPedia and other public sources like WikiData, and I wanted to experiment with partially automating this exploration process.

\n\n\n

\nDBPedia Question Answering System Using SparQL and Deep Learning

\n\n

The Jupyter notebook for this example is available on Google Colab DBPedia Question Answering System

\n\n

The example is also in the GitHub repository for this book in the jupyter_notesbooks directory (includes both notebook format files and a Python source file):

\n\n

 1 # DBPedia Question Answering System\n 2 # Copyright 2021-2022 Mark Watson. All rights reserved. License: Apache 2\n 3 \n 4 !pip install transformers\n 5 !pip install SPARQLWrapper\n 6 !pip freeze\n 7 \n 8 from transformers import pipeline\n 9 \n10 qa = pipeline(\n11     \"question-answering\",\n12     #model=\"NeuML/bert-small-cord19qa\",\n13     model=\"NeuML/bert-small-cord19-squad2\",\n14     tokenizer=\"NeuML/bert-small-cord19qa\"\n15 )\n

\n\n\n\n

TBD:

\n\n

1 !pip install import spacy\n2 !python -m spacy download en_core_web_sm\n3 \n4 import spacy\n5 \n6 nlp_model = spacy.load('en_core_web_sm')\n

\n\n\n\n

TBD:

\n\n

1 from SPARQLWrapper import SPARQLWrapper, JSON\n2 \n3 sparql = SPARQLWrapper(\"http://dbpedia.org/sparql\")\n4 \n5 def query(query):\n6   sparql.setQuery(query)\n7   sparql.setReturnFormat(JSON)\n8   return sparql.query().convert()['results']['bindings']\n

\n\n\n\n

TBD:

\n\n

 1 def entities_in_text(s):\n 2     doc = nlp_model(s)\n 3     ret = {}\n 4     for [ename, etype] in [[entity.text, entity.label_] for entity in doc.ents]:\n 5         if etype in ret:\n 6             ret[etype] = ret[etype] + [ename]\n 7         else:\n 8             ret[etype] = [ename]\n 9     return ret\n10 \n11 def dbpedia_get_entities_by_name(name, dbpedia_type):\n12   sparql = \"select distinct ?s ?comment where {{ ?s <http://www.w3.org/2000/01/rdf-s\\\n13 chema#label>  \\\"{}\\\"@en . ?s <http://www.w3.org/2000/01/rdf-schema#comment>  ?commen\\\n14 t  . FILTER  (lang(?comment) = 'en') . ?s <http://www.w3.org/1999/02/22-rdf-syntax-n\\\n15 s#type> {} . }} limit 15\".format(name, dbpedia_type)\n16   #print(sparql)\n17   results = query(sparql)\n18   return(results)\n19 \n20 entity_type_to_type_uri = {'PERSON': '<http://dbpedia.org/ontology/Person>',\n21     'GPE': '<http://dbpedia.org/ontology/Place>', 'ORG':\n22     '<http://dbpedia.org/ontology/Organisation>'}\n

\n\n\n\n

TBD:

\n\n

 1 def QA(query_text):\n 2   entities = entities_in_text(query_text)\n 3 \n 4   def helper(entity_type):\n 5     ret = \"\"\n 6     if entity_type in entities:\n 7       for hname in entities[entity_type]:\n 8         results = dbpedia_get_entities_by_name(hname, entity_type_to_type_uri[entity\\\n 9 _type])\n10         for result in results:\n11           ret += ret + result['comment']['value'] + \" . \"\n12     return ret\n13 \n14   context_text = helper('PERSON') + helper('ORG') + helper('GPE')\n15   print(\"\\ncontext text:\\n\", context_text, \"\\n\")\n16 \n17   print(\"Answer from transformer model:\")\n18   print(\"Original query: \", query_text)\n19   print(\"Answer:\")\n20 \n21   answer = qa({\n22                 \"question\": query_text,\n23                 \"context\": context_text\n24                })\n25   print(answer)\n

\n\n\n\n

TBD:

\n\n

1 QA(\"where does Bill Gates work?\")\n2 QA(\"where is IBM is headquartered?\")\n3 QA(\"who is Bill Clinton married to?\")\n4 QA(\"what is the population of Paris?\")\n

\n\n\n\n

Program output is:

\n\n

 1 context text:\n 2  William Henry Gates III (born October 28, 1955) is an American business magnate, so\\\n 3 ftware developer, investor, author, and philanthropist. He is a co-founder of Micros\\\n 4 oft, along with his late childhood friend Paul Allen. During his career at Microsoft\\\n 5 , Gates held the positions of chairman, chief executive officer (CEO), president and\\\n 6  chief software architect, while also being the largest individual shareholder until\\\n 7  May 2014. He is considered one of the best known entrepreneurs of the microcomputer\\\n 8  revolution of the 1970s and 1980s. .  \n 9 \n10 Answer from transformer model:\n11 Original query:  where does Bill Gates work?\n12 Answer:\n13 {'score': 0.3949914574623108, 'start': 242, 'end': 251, 'answer': 'Microsoft'}\n14 \n15 context text:\n16  International Business Machines Corporation (IBM) is an American multinational tech\\\n17 nology corporation headquartered in Armonk, New York, with operations in over 171 co\\\n18 untries. The company began in 1911, founded in Endicott, New York by trust businessm\\\n19 an Charles Ranlett Flint, as the Computing-Tabulating-Recording Company (CTR) and wa\\\n20 s renamed \"International Business Machines\" in 1924. IBM is incorporated in New York\\\n21 . .  \n22 \n23 Answer from transformer model:\n24 Original query:  where is IBM is headquartered?\n25 Answer:\n26 {'score': 0.8817499279975891, 'start': 119, 'end': 135, 'answer': 'Armonk, New York'}\n27 \n28 context text:\n29  William Jefferson Clinton (né Blythe III; born August 19, 1946) is an American poli\\\n30 tician and attorney who served as the 42nd president of the United States from 1993 \\\n31 to 2001. He previously served as governor of Arkansas from 1979 to 1981 and again fr\\\n32 om 1983 to 1992, and as attorney general of Arkansas from 1977 to 1979. A member of \\\n33 the Democratic Party, Clinton became known as a New Democrat, as many of his policie\\\n34 s reflected a centrist \"Third Way\" political philosophy. He is the husband of Hillar\\\n35 y Clinton, who was secretary of state from 2009 to 2013 and the Democratic nominee f\\\n36 or president in the 2016 presidential election. .  \n37 \n38 Answer from transformer model:\n39 Original query:  who is Bill Clinton married to?\n40 Answer:\n41 {'score': 0.0006518915179185569, 'start': 497, 'end': 512, 'answer': 'Hillary Clinto\\\n42 n'}\n43 \n44 context text:\n45  Paris (French pronunciation: [paʁi]) is the capital and most populous city of Fran\\\n46 ce, with an estimated population of 2,175,601 residents as of 2018, in an area of mo\\\n47 re than 105 square kilometres (41 square miles). Since the 17th century, Paris has b\\\n48 een one of Europe's major centres of finance, diplomacy, commerce, fashion, gastrono\\\n49 my, science, and arts. The City of Paris is the centre and seat of government of the\\\n50  region and province of Île-de-France, or Paris Region, which has an estimated popul\\\n51 ation of 12,174,880, or about 18 percent of the population of France as of 2017. The\\\n52  Paris Region had a GDP of €709 billion ($808 billion) in 2017. According to the Eco\\\n53 nomist Intelligence Unit Worldwide Cost of Living Survey in 2018, Paris was the seco\\\n54 nd most expensive city in the world, after .  \n55 \n56 Answer from transformer model:\n57 Original query:  what is the population of Paris?\n58 Answer:\n59 {'score': 0.787605345249176, 'start': 119, 'end': 128, 'answer': '2,175,601'}\n

\n\n\n\n\n

\nPart V - GOFAI - Good Old Fashioned Symbolic Artificial Intelligence

\n\n

TBD- symbolic AI

\n\n\n

\nPart VI - Hybrid Symbolic and Deep Learning Approaches to Artificial Intelligence

\n\n

TBD- hybrid AI

\n\n\n

\nPart VII - Miscellaneous Code and Techniques

\n\n

TBD

\n\n\n

\nUsing the Microsoft Bing Search APIs

\n\n

TBD: CONVERT EXAMPLES FROM Hylang to PYTHON!!

\n\n

You will need to register with Microsoft’s Azure search service to use the material in this chapter. It is likely that you view search as a manual human-centered activity. I hope to expand your thinking to considering applications that automate search, finding information on the web, and automatically organizing information.

\n\n

\nGetting an Access Key for Microsoft Bing Search APIs

\n\n

You will need an Azure account. I use the Bing search APIs fairly often for research but I have never spent more than about a dollar a month and usually I get no bill at all. For personal use it is an inexpensive service.

\n\n

Get started by going to the web page https://azure.microsoft.com/en-us/try/cognitive-services/ and sign up for an access key. The Search APIs signup is currently in the fourth tab in this web form. When you navigate to the Search APIs tab, select the option Bing Search APIs v7. You will get an API key that you need to store in an environment variable that you will soon need:

\n\n

export BING_SEARCH_V7_SUBSCRIPTION_KEY=4e97234341d9891191c772b7371ad5b1\n

\n\n\n\n

That is not my real subscription key!

\n\n

After adding this to your .profile file (or .zshrc, or .bashrc, or etc.), open a new terminal window and make sure the following works for you:

\n\n

$ hy\nhy 0.18.0 using CPython(default) 3.7.4 on Darwin\n=> (import os)\n=> (get os.environ \"BING_SEARCH_V7_SUBSCRIPTION_KEY\")\n'4e97234341d9891191c772b7371ad5b1'\n=> \n

\n\n\n\n

\nExample Search Script

\n\n

It takes very little Hy code to access the Bing search APIs. We will look at a long example script that expects a single command line argument that is a string containing search terms. The following example script shows you how to make a search query that requests search results in JSON format. We also look at parsing the returned JSON data. I formatted this listing to fit the page width:

\n\n

#!/usr/bin/env hy\n\n(import json)\n(import os)\n(import sys)\n(import [pprint [pprint]])\n(import requests)\n\n;; Add your Bing Search V7 subscription key and \n;; the endpoint to your environment variables.\n(setv subscription_key (get os.environ \"BING_SEARCH_V7_SUBSCRIPTION_KEY\"))\n(setv endpoint \"https://api.cognitive.microsoft.com/bing/v7.0/search\")\n\n;; Query term(s) to search for. \n(setv query (get sys.argv 1)) ;; an example: \"site:wikidata.org Sedona Arizona\"\n\n;; Construct a request\n(setv mkt \"en-US\")\n(setv params { \"q\" query \"mkt\" mkt })\n(setv headers { \"Ocp-Apim-Subscription-Key\" subscription_key })\n\n;; Call the API\n(setv response (requests.get endpoint :headers headers :params params))\n\n(print \"\\nFull JSON response from Bing search query:\\n\")\n(pprint (response.json))\n\n;; pull out resuts and print them individually:\n\n(setv results (get (response.json) \"webPages\"))\n\n(print \"\\nResults from the key 'webPages':\\n\")\n(pprint results)\n\n(print \"\\nDetailed printout from the first search result:\\n\")\n\n(setv result-list (get results \"value\"))\n(setv first-result (first result-list))\n\n(print \"\\nFirst result, all data:\\n\")\n(pprint first-result)\n\n(print \"\\nSummary of first search result:\\n\")\n(pprint (get first-result \"displayUrl\"))\n\n(if (in \"displayUrl\" first-result)\n    (print\n     (.format\n       \" key: {:15} \\t:\\t {}\" \"displayUrl\"\n       (get first-result \"displayUrl\"))))\n(if (in \"language\" first-result)\n    (print\n      (.format \" key: {:15} \\t:\\t {}\" \"language\" \n      (get first-result \"language\"))))\n(if (in \"name\" first-result)\n    (print \n      (.format \n        \" key: {:15} \\t:\\t {}\" \"name\" \n        (get first-result \"name\"))))\n

\n\n\n\n

You can use search hints like “site:wikidata.org” to only search specific web sites. In the following example I use the search query:

\n\n

1 \"site:wikidata.org Sedona Arizona\"\n

\n\n\n\n

This example generates 364 lines of output so I only show a few selected lines here:

\n\n

$ ./bing.hy \"site:wikidata.org Sedona Arizona\" | wc -l\n     364\n$ ./bing.hy \"site:wikidata.org Sedona Arizona\"\n\nFull JSON response from Bing search query:\n\n{'_type': 'SearchResponse',\n 'queryContext': {'originalQuery': 'site:wikidata.org Sedona Arizona'},\n \n   ...\n\nResults from the key 'webPages':\n\n{'totalEstimatedMatches': 27,\n 'value': [{'about': [{'name': 'Sedona'}, {'name': 'Sedona'}],\n            'dateLastCrawled': '2020-05-24T00:04:00.0000000Z',\n            'displayUrl': 'https://www.wikidata.org/wiki/Q80041',\n    ...\n\nSummary of first search result:\n\n'https://www.wikidata.org/wiki/Q80041'\n key: displayUrl      \t:\t https://www.wikidata.org/wiki/Q80041\n key: language        \t:\t en\n key: name            \t:\t Sedona - Wikidata\n

\n\n\n\n

\nWrap-up

\n\n

In addition to using automated web scraping to get data for my personal research, I often use automated web search. I find the Microsoft’s Azure Bing search APIs are the most convenient to use and I like paying for services that I use. The search engine Duck Duck Go also provides free search APIs but even though I use Duck Duck Go for 90% of my manual web searches, when I build automated systems I prefer to rely on services that I pay for.

\n\n\n

\nResponsible Web Scraping

\n\n

TBD: CONVERT EXAMPLES FROM Hylang to PYTHON!!

\n\n

I put the word “Responsible” in the chapter title to remind you that just because it is easy (as we will soon see) to pull data from web sites, it is important to respect the property rights of web site owners and abide by their terms and conditions for use. This Wikipedia article on Fair Use provides a good overview of using copyright material.

\n\n

The web scraping code we develop here uses the Python BeautifulSoup and URI libraries.

\n\n

For my work and research, I have been most interested in using web scraping to collect text data for natural language processing but other common applications include writing AI news collection and summarization assistants, trying to predict stock prices based on comments in social media which is what we did at Webmind Corporation in 2000 and 2001, etc.

\n\n

\nUsing the Python BeautifulSoup Library in the Hy Language

\n\n

There are many good libraries for parsing HTML text and extracting both structure (headings, what is in bold font, etc.) and embedded raw text. I particularly like the Python Beautiful Soup library and we will use it here.

\n\n

In line 4 for the following listing of file get_web_page.hy, I am setting the default user agent to a descriptive string “HyLangBook” but for some web sites you might need to set this to appear as a Firefox or Chrome browser (iOS, Android, Windows, Linux, or macOS). The function get-raw-data gets the entire contents of a web site as a single string value.

\n\n

1 (import [urllib.request [Request urlopen]])\n2 \n3 (defn get-raw-data-from-web [aUri\n4                              &optional [anAgent {\"User-Agent\" \"HyLangBook/1.0\"}]]\n5   (setv req (Request aUri :headers anAgent))\n6   (setv httpResponse (urlopen req))\n7   (setv data (.read httpResponse))\n8   data)\n

\n\n\n\n

Let’s test this function in a REPL:

\n\n

 1 $ hy\n 2 hy 0.17.0+108.g919a77e using CPython(default) 3.7.3 on Darwin\n 3 => (import [get-page-data [get-raw-data-from-web]])\n 4 => (get-raw-data-from-web \"http://knowledgebooks.com\")\n 5 b'<!DOCTYPE html><html><head><title>KnowledgeBooks.com - research on the Knowledge M\\\n 6 anagement, and the Semantic Web ...'\n 7 => \n 8 => (import [get-page-data [get-page-html-elements]])\n 9 => (get-page-html-elements \"http://knowledgebooks.com\")\n10 {'title': [<title>KnowledgeBooks.com - research on the Knowledge Management, and the\\\n11  Semantic Web </title>],\n12 'a': [<a class=\"brand\" href=\"#\">KnowledgeBooks.com  </a>,  ...\n13 => \n

\n\n\n\n

This REPL session shows the the function get-raw-data-from-web defined in the previous listing returns a web page as a string. In line 9 we use a function get-page-html-elements to find all elements in a string containing HTML. This function is defined in the next listing and shows how to parse and process the string contents of a web pages. Note: you will need to install the lxml library for this example (using pip or pip3 depending on your Python configuration):

\n\n

1 pip install lxml\n

\n\n\n\n

The following listing of file get_page_data.hy uses the Beautiful Soup library to parse the string data for HTML text from a web site. The function get-page-html-elements returns names and associated data with each element in HTML represented as a string (the extra code on lines 20-24 is just debug example code):

\n\n

 1 (import [get_web_page [get-raw-data-from-web]])\n 2 \n 3 (import [bs4 [BeautifulSoup]])\n 4 \n 5 (defn get-element-data [anElement]\n 6   {\"text\" (.getText anElement)\n 7    \"name\" (. anElement name)\n 8    \"class\" (.get anElement \"class\")\n 9    \"href\" (.get anElement \"href\")})\n10 \n11 (defn get-page-html-elements [aUri]\n12   (setv raw-data (get-raw-data-from-web aUri))\n13   (setv soup (BeautifulSoup raw-data \"lxml\"))\n14   (setv title (.find_all soup \"title\"))\n15   (setv a (.find_all soup \"a\"))\n16   (setv h1 (.find_all soup \"h1\"))\n17   (setv h2 (.find_all soup \"h2\"))\n18   {\"title\" title \"a\" a \"h1\" h1 \"h2\" h2})\n19 \n20 (setv elements (get-page-html-elements \"http://markwatson.com\"))\n21 \n22 (print (get elements \"a\"))\n23 \n24 (for [ta (get elements \"a\")] (print (get-element-data ta)))\n

\n\n\n\n

The function get-element-data defined in lines 5-9 accepts as an argument an HTML element object (as defined in the Beautiful soup library) and extracts data, if available, for text, name, class, and href values. The function get-page-html-elements defied in lines 11-18 accepts as an argument a string containing a URI and returns a dictionary (or map, or hashtable) containing lists of all a, h1, h2, and title elements in the web page pointed to by the input URI. You can modify get-page-html-elements to add additional HTML element types, as needed.

\n\n

Here is the output (with many lines removed for brevity):

\n\n

 1 {'text': 'Mark Watson artificial intelligence consultant and author',\n 2  'name': 'a', 'class': ['navbar-brand'], 'href': '#'}\n 3 {'text': 'Home page', 'name': 'a', 'class': None, 'href': '/'}\n 4 {'text': 'My Blog', 'name': 'a', 'class': None,\n 5  'href': 'https://mark-watson.blogspot.com'}\n 6 {'text': 'GitHub', 'name': 'a', 'class': None,\n 7  'href': 'https://github.com/mark-watson'}\n 8 {'text': 'Twitter', 'name': 'a', 'class': None, 'href': 'https://twitter.com/mark_l_\\\n 9 watson'}\n10 {'text': 'WikiData', 'name': 'a', 'class': None, 'href': 'https://www.wikidata.org/w\\\n11 iki/Q18670263'}\n

\n\n\n\n

\nGetting HTML Links from the DemocracyNow.org News Web Site

\n\n

I financially support and rely on both NPR.org and DemocracyNow.org news as my main sources of news so I will use their news sites for examples here and in the next section. Web sites differ so much in format that it is often necessary to build highly customized web scrapers for individual web sites and to maintain the web scraping code as the format of the site changes in time.

\n\n

Before working through this example and/or the example in the next section use the file Makefile to fetch data:

\n\n

make data\n

\n\n\n\n

This should copy the home pages for both web sites to the files:

\n\n

democracynow_home_page.html (used here)
npr_home_page.html (used for the example in the next section)

\n\n

The following listing shows democracynow_front_page.hy

\n\n

 1 #!/usr/bin/env hy\n 2 \n 3 (import [get-web-page [get-web-page-from-disk]])\n 4 (import [bs4 [BeautifulSoup]])\n 5 \n 6 ;; you need to run 'make data' to fetch sample HTML data for dev and testing\n 7 \n 8 (defn get-democracy-now-links []\n 9   (setv test-html (get-web-page-from-disk \"democracynow_home_page.html\"))\n10   (setv bs (BeautifulSoup test-html :features \"lxml\"))\n11   (setv all-anchor-elements (.findAll bs \"a\"))\n12   (lfor e all-anchor-elements\n13           :if (> (len (.get-text e)) 0)\n14           (, (.get e \"href\") (.get-text e))))\n15 \n16 (if (= __name__ \"__main__\")\n17   (for [[uri text] (get-democracy-now-links)]\n18     (print uri \":\" text)))\n

\n\n\n\n

This simply prints our URIs and text (separated with the string “:”) for each link on the home page. On line 13 we discard any anchor elements that do not contain text. On line 14 the comma character at the start of the return list indicates that we are constructing a tuple. Lines 16-18 define a main function that is used when running this file art the command line. This is similar to how main functions can be defined in Python to allow a library file to also be run as a command line tool.

\n\n

A few lines of output from today’s front page is:

\n\n

/2020/1/7/the_great_hack_cambridge_analytica : Meet Brittany Kaiser, Cambridge Analy\\\ntica Whistleblower Releasing Troves of New Files from Data Firm\n/2019/11/8/remembering_orangeburg_massacre_1968_south_carolina : Remembering the 196\\\n8 Orangeburg Massacre When Police Shot Dead Three Unarmed Black Students\n/2020/1/15/democratic_debate_higher_education_universal_programs : Democrats Debate \\\nWealth Tax, Free Public College & Student Debt Relief as Part of New Economic Plan\n/2020/1/14/dahlia_lithwick_impeachment : GOP Debate on Impeachment Witnesses Intensi\\\nfies as Pelosi Prepares to Send Articles to Senate\n/2020/1/14/oakland_california_moms_4_housing : Moms 4 Housing: Meet the Oakland Moth\\\ners Facing Eviction After Two Months Occupying Vacant House\n/2020/1/14/luis_garden_acosta_martin_espada : “Morir Soñando”: Martín Espada Reads P\\\noem About Luis Garden Acosta, Young Lord & Community Activist\n

\n\n\n\n

The URIs are relative to the root URI https://www.democracynow.org/.

\n\n

\nGetting Summaries of Front Page from the NPR.org News Web Site

\n\n

This example is similar to the example in the last section except that text from home page links is formatted to provide a daily news summary. I am assuming that you ran the example in the last section so the web site home pages have been copied to local files.

\n\n

The following listing shows npr_front_page_summary.hy

\n\n

 1 #!/usr/bin/env hy\n 2 \n 3 (import [get-web-page [get-web-page-from-disk]])\n 4 (import [bs4 [BeautifulSoup]])\n 5 \n 6 ;; you need to run 'make data' to fetch sample HTML data for dev and testing\n 7 \n 8 (defn get-npr-links []\n 9   (setv test-html (get-web-page-from-disk \"npr_home_page.html\"))\n10   (setv bs (BeautifulSoup test-html :features \"lxml\"))\n11   (setv all-anchor-elements (.findAll bs \"a\"))\n12   (setv filtered-a\n13     (lfor e all-anchor-elements\n14           :if (> (len (.get-text e)) 0)\n15           (, (.get e \"href\") (.get-text e))))\n16   filtered-a)\n17 \n18 (defn create-npr-summary []\n19   (setv links (get-npr-links))\n20   (setv filtered-links (lfor [uri text] links :if (> (len (.strip text)) 40) (.strip\\\n21  text)))\n22   (.join \"\\n\\n\" filtered-links))\n23 \n24 (if (= __name__ \"__main__\")\n25   (print (create-npr-summary)))\n

\n\n\n\n

In lines 12-15 we are filtering out (or removing) all anchor HTML elements that do not contain text. The following shows a few lines of the generated output for data collected today:

\n\n

January 16, 2020  Birds change the shape of their wings far more than\nplanes. The complexities of bird flight have posed a major design challenge\nfor scientists trying to translate the way birds fly into robots.\n\nFBI Vows To Warn More Election Officials If Discovering A Cyberattack\n\nJanuary 16, 2020  The bureau was faulted after the Russian attack on the\n2016 election for keeping too much information from state and local\nauthorities. It says it'll use a new policy going forward.\n\nUkraine Is Investigating Whether U.S. Ambassador Yovanovitch Was Surveilled\n\nJanuary 16, 2020  Ukraine's Internal Affairs Ministry says it's asking the\nFBI to help determine whether international laws were broken, or \"whether it\nis just a bravado and a fake information\" from a U.S. politician.\n\nElectric Burn: Those Who Bet Against Elon Musk And Tesla Are Paying A Big Price\n\nJanuary 16, 2020  For years, Elon Musk skeptics have shorted Tesla stock, confident \\\nthe electric carmaker was on the brink of disaster. Instead, share value has skyrock\\\neted, costing short sellers billions.\n\nTSA Says It Seized A Record Number Of Firearms At U.S. Airports Last Year\n

\n\n\n\n

The examples seen here are simple but should be sufficient to get you started gathering text data from the web.

\n\n\n

\nDisplaying Graph Data Using PyGraphViz

\n\n

This example can be found in Colab notebook pygraphviz demo

\n\n

TBD:

\n\n

1 !apt install libgraphviz-dev\n2 !pip install pygraphviz\n3 \n4 import pygraphviz as pgv\n5 from IPython.display import Image\n

\n\n\n\n

TBD:

\n\n

 1 d={'1': {'2': None, '3': None}, '2': {'4': None, '5': None}, '3': {'2': None},\n 2    '5': {'go':None}, 'go':{'1':None}}\n 3 A=pgv.AGraph(d, directed=True)\n 4 edge = A.get_edge('1', '3')\n 5 edge.attr['label'] = 'Sales'\n 6 \n 7 A.to_string()\n 8 A.layout()\n 9 A.draw('file.png')\n10 \n11 Image('file.png')\n

\n\n\n\n

The output is:

\n\n

 1 d={'1': {'2': None, '3': None}, '2': {'4': None, '5': None}, '3': {'2': None},\n 2    '5': {'go':None}, 'go':{'1':None}}\n 3 A=pgv.AGraph(d, directed=True)\n 4 edge = A.get_edge('1', '3')\n 5 edge.attr['label'] = 'Sales'\n 6 \n 7 A.to_string()\n 8 A.layout()\n 9 A.draw('file.png')\n10 \n11 Image('file.png')\n

\n\n\n\n\n

\n\n\n\n

\nIntroduction to Programming Quantum Computing

\n\n

Although you can now get cloud computing access from Amazon AWS and Microsoft Azure to existing quantum computing hardware, here we will take a light approach: review just enough math for you to understand the basics of quantum computing and accessing quantum computing simulators in a few Hy language examples. I try hard to cover material in my books that will be of immediate practical use to my readers but this chapter is more forward thinking, hopefully introducing you to ideas that will be useful when quantum computers are scaled to solve a wider range of practical problems. To be honest, the material in this chapter is really for my use to learn enough about quantum technology to use it when appropriate in the future. I hope that you also benefit from tinkering with early quantum technology.

\n\n

Quantum computers may add exponentially fast computation over conventional computer architectures and another important application may be world wide quantum entangle networks that would (hopefully) provide un-hackable communications for financial institutions, government, and military applications.

\n\n

Quantum networks will be based on the property of entanglement and we will build an example of entanglement later.

\n\n

The idea of quantum entanglement is simple: two quantum particles share the same information no matter how far apart they are.

\n\n

Experimentally, if you measure one paired (or entangled) particle then any measurement you perform immediately influences the other entangled particle. Albert Einstein (who my father knew when they both worked at the Institute for Advanced Studies) called this effect “spooky action at a distance.” Spooky indeed!

\n\n

\nResources

\n\n

We will be using the pyQuil library (GitHub repo) and use the paper A Practical Quantum Instruction Set Architecture by Robert Smith, Michael Curtis, and William Zeng as a reference.

\n\n

Please note that you will need a free API key from Rigetti to follow along with the following examples. You can sign up here.

\n\n

\nThe Math You Will Need to Know

\n\n

TBD

\n\n

\nA Quick Tour of Quantum Information Theory

\n\n

TBD

\n\n

\nAvalaible Software Simulators and Tools

\n\n

TBD

\n\n

\nHy Language Examples

\n\n\n

\nBook Wrap Up

\n\n

Thank you for reading my book. I hope that I have met my goals of providing you with both interesting material to expand the way you think about human and computer cognition and also to provide you with actionable knowledge in your own work.

\n\n

\nMy Other Books That Might Interest You

\n\n

Interested in Machine Learning using Java? Buy my book Power Java\n
Interested in General Artificial Intelligence material using Java? Buy my book Practical Artificial Intelligence Programming wth Java\n
Interested in Knowledge Management, Knowledge Representation and Linked Data (Semantic Web)? Get a free PDF of my books Practical Semantic Web and Linked Data Applications, Java, Scala, Clojure, and JRuby Edition and Practical Semantic Web and Linked Data Applications, Common Lisp Edition\n

\n\n

\n\n","tocStructure",[388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466],{"_75":76,"_43":77,"_70":-5,"_78":79,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":85,"_70":-5,"_78":86,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":91,"_70":-5,"_78":92,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":95,"_70":-5,"_78":96,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":98,"_70":-5,"_78":99,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":101,"_70":-5,"_78":102,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":104,"_70":-5,"_78":105,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":107,"_70":-5,"_78":108,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":111,"_70":-5,"_78":112,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":115,"_70":-5,"_78":116,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":118,"_70":-5,"_78":119,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":121,"_70":-5,"_78":122,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":124,"_70":-5,"_78":125,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":127,"_70":-5,"_78":128,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":130,"_70":-5,"_78":131,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":133,"_70":-5,"_78":134,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":136,"_70":-5,"_78":137,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":139,"_70":-5,"_78":140,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":143,"_70":-5,"_78":144,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":147,"_70":-5,"_78":148,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":151,"_70":-5,"_78":152,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":155,"_70":-5,"_78":156,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":158,"_70":-5,"_78":159,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":161,"_70":-5,"_78":162,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":165,"_70":-5,"_78":166,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":168,"_70":-5,"_78":169,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":172,"_70":-5,"_78":173,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":175,"_70":-5,"_78":176,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":178,"_70":-5,"_78":179,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":181,"_70":-5,"_78":182,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":185,"_70":-5,"_78":186,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":189,"_70":-5,"_78":190,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":193,"_70":-5,"_78":194,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":196,"_70":-5,"_78":197,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":199,"_70":-5,"_78":200,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":202,"_70":-5,"_78":203,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":205,"_70":-5,"_78":206,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":209,"_70":-5,"_78":210,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":213,"_70":-5,"_78":214,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":217,"_70":-5,"_78":218,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":221,"_70":-5,"_78":222,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":225,"_70":-5,"_78":226,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":228,"_70":-5,"_78":229,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":231,"_70":-5,"_78":232,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":234,"_70":-5,"_78":235,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":237,"_70":-5,"_78":238,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":241,"_70":-5,"_78":242,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":244,"_70":-5,"_78":245,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":247,"_70":-5,"_78":248,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":250,"_70":-5,"_78":251,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":202,"_70":-5,"_78":253,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":255,"_70":-5,"_78":256,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":259,"_70":-5,"_78":260,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":262,"_70":-5,"_78":263,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":265,"_70":-5,"_78":266,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":268,"_70":-5,"_78":269,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":271,"_70":-5,"_78":272,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":202,"_70":-5,"_78":274,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":276,"_70":-5,"_78":277,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":280,"_70":-5,"_78":281,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":284,"_70":-5,"_78":285,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":288,"_70":-5,"_78":289,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":292,"_70":-5,"_78":293,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":296,"_70":-5,"_78":297,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":299,"_70":-5,"_78":300,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":202,"_70":-5,"_78":302,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":304,"_70":-5,"_78":305,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":308,"_70":-5,"_78":309,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":311,"_70":-5,"_78":312,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":314,"_70":-5,"_78":315,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":317,"_70":-5,"_78":318,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":321,"_70":-5,"_78":322,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":325,"_70":-5,"_78":326,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":328,"_70":-5,"_78":329,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":331,"_70":-5,"_78":332,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":334,"_70":-5,"_78":335,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":337,"_70":-5,"_78":338,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":76,"_43":340,"_70":-5,"_78":341,"_71":80,"_87":-5,"_88":-5,"_89":-5},{"_75":84,"_43":344,"_70":-5,"_78":345,"_71":80,"_87":-5,"_88":-5,"_89":-5},"publicChapterContent","nextChapter","sections",[],"routes/_store+/_layout","routes/_store+/_readers+/_layout","actionData","errors"]

\nPart VI - Hybrid Symbolic and Deep Learning Approaches to Artificial Intelligence

Table of Contents

\nCover Material, Copyright, and License

\nThis book is licensed with Creative Commons Attribution CC BY Version 3 That Allows Reuse In Derived Works

\nPreface

\nProgramming Examples in this Book

\nWorking with the examples

\nA Request from the Author

\nCredits

\nPart I - A Brief Introduction to AI and Effectively Using Python

\nAn Introduction to Artificial Intelligence

\nOverview

\nAn Overview of How the Human Brain Works

\nIntroduction to Artificial Neural Networks

\nSymbolic Representation of Facts and Rules (Expert Systems)

\nSymbolic Models for Natural Language Processing

\nUsing Deep Learning for Natural Language Processing

\nAn Overview of Linguistics

\nPhonology

\nMorphology

\nSyntax

\nSemantics

\nPragmatics

\nLinguistics Wrap Up And Practical Applications

\nThe Public’s Perception of Artificial Intelligence

\nPython Tips and Techniques

\nEthics and Human Values

\nPart II - Machine Learning and Deep Learning

\n(Almost) Everything You Really Need To Know About Machine Learning

\nIntroduction to Supervised and Unsupervised Learning

\nFeature Engineering

\nFeature Engineering for Text Data

\nFeature Engineering for Numeric Data

\nTensoflow and Keras Model for Wisconsin Cancer Data Set

\nJupyter Notebook

\nUsing TensorFlow for Implementing Deep Neural Networks

\nInstalling TensorFlow and Keras

\nProcessing Cancer Data With a BackPropagation Network

\nDeep Learning Wrap Up

\nGenerating Images With Deep Learning

\nPart III - Natural Language Processing

\nIntroduction to Natural Language Processing

\nExploring the spaCy Library

\nImplementing a HyNLP Wrapper for the Python spaCy Library

\nCoreference (Anaphora Resolution)

\nWrap-up

\nEntity Detection

\nText Generation

\nPart IV - Knowledge Representation Using Semantic Web Technologies

\nKnowledge Representation Using the Neo4J Graph Database

\nLinked Data and the Semantic Web

\nUnderstanding the Resource Description Framework (RDF)

\nResource Namespaces Provided in rdflib

\nUnderstanding the SPARQL Query Language

\nUsing the Python rdflib Library

\nKnowledge Graph Creator

\nRecommended Industrial Use of Knowledge Graphs

\nDesign of KGCreator Application

\nProblems with using Literal Values in RDF

\nRevisiting This Example Using URIs Instead of Literal Values

\nWrap-up

\nKnowledge Graph Navigator

\nReview of NLP Utilities Used in Application

\nDeveloping Low-Level Caching SPARQL Utilities

\nSPARQL Utilities

\nUtilities to Colorize SPARQL and Generated Output

\nText Utilities for Queries and Results

\nFinishing the Main Function for KGN

\nWrap-up

\nDBPedia Question Answering System Using SparQL and Deep Learning

\nPart V - GOFAI - Good Old Fashioned Symbolic Artificial Intelligence

\nPart VI - Hybrid Symbolic and Deep Learning Approaches to Artificial Intelligence

\nPart VII - Miscellaneous Code and Techniques

\nUsing the Microsoft Bing Search APIs

\nGetting an Access Key for Microsoft Bing Search APIs

\nExample Search Script

\nWrap-up

\nResponsible Web Scraping

\nUsing the Python BeautifulSoup Library in the Hy Language

\nGetting HTML Links from the DemocracyNow.org News Web Site