Data import / export via struct annotation #
Structure annotations #
This section demonstrates how can we convert simple or complex objects and their properties to quads.
it also shows how can we directly upload these data structures to the store, using the annotations placed into the struct
declarations ob the objects. Moreover there are examples to the retrieval of these complex objects from the store.
Within this method it is much easier to store/retrieve complex data structures, than doing it directly with the quads that these data structures are made of, and collecting their properties one-by-one.
Create store #
In the examples we will use a simple in-memory store.
We can start using such a store via calling the InitStore()
function, that we can find in the store.go
file.
Show the source code of the `store.go`
package kbase
import (
"github.com/cayleygraph/cayley"
"log"
)
// Create a mem-store for testing
func InitStore() *cayley.Handle {
store, err := cayley.NewMemoryGraph()
if err != nil {
log.Fatalln(err)
}
return store
}
Test data #
The bookmarks.yml
file holds the test data in YAML format. it contains a list of bookmarks.
We will upload these bookmarks, then we will query them. The results of the queries will be retrieved via the help of struct
annotations.
Show the `bookmarks.yml` file
- id: 9493efb9-be9a-4435-9b5d-f605fc9cddaa
title: Gremlin's Graph Traversal Machinery
content: ""
author: ""
published: ""
tags: [gremlin, cayley, tinkerprop, gizmo, presentation, graph-db, query-language]
urls: ['https://www.slideshare.net/slidarko/gremlins-graph-traversal-machinery']
- id: d6481271-d42d-487c-bec9-733ff383e029
title: Ontotext GraphDB
content: ""
author: ""
published: ""
tags: [graphdb, nosql, knowledge-graph, linked-data, semantic-web, rdf]
urls: ['https://ontotext.com/products/graphdb/']
- id: 058d41d5-6830-432b-8ebb-5733f8a2575b
title: 'Graphs and neural networks: Reading node properties'
content: ""
author: David Mack
published: ""
tags: [octavian-ai, graphs, neural-network, nlu, digital-assistant, dbms, brainputer,
knowledge-graphs, graph-databases]
urls: ['https://medium.com/octavian-ai/graphs-and-neural-networks-reading-node-properties-2c91625980eb']
- id: 324bacb5-8709-42b9-b38b-93755c48ef19
title: Towards building the next generation database query engine
content: ""
author: David Mack
published: Nov 12, 2018
tags: [octavian-ai, graphs, neural-network, nlu, digital-assistant, dbms, brainputer,
knowledge-graphs, graph-databases]
urls: ['https://medium.com/octavian-ai/towards-building-the-next-generation-database-query-engine-a1beca1e07a3']
- id: e0af0cdc-1795-482d-986e-96b08cc530f9
title: extracting-knowledge-from-knowledge-graphs
content: ""
author: ""
published: ""
tags: [brainputer, pythorch, knowlendge-graph]
urls: ['https://towardsdatascience.com/extracting-knowledge-from-knowledge-graphs-e5521e4861a0']
- id: 2e75fc6a-148f-4016-a178-2a53a67e06c8
title: Platypus
content: ""
author: ""
published: ""
tags: [knowledge-graph, wikidata, cognition, cui, platypus]
urls: ['https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/A_gentle_introduction_to_the_Wikidata_Query_Service',
'https://www.wikidata.org/wiki/Wikidata:Main_Page', 'https://hal.archives-ouvertes.fr/hal-01730479/document']
- id: 46721a5a-0eda-48f4-b190-b1c2544146a4
title: Grakn.AI - learn
content: ""
author: ""
published: ""
tags: [grakn.ai, tutorials, blog, ai, inference-engine, knowledge-graph]
urls: ['https://blog.grakn.ai/learn/home']
- id: 418b7162-fc1e-4dda-a6a5-80b9d4558f47
title: 'KagNet: Knowledge-Aware Graph Networks for Commonsense Reasoning'
content: ""
author: ""
published: ""
tags: [kagnet, cognitive-computating, python, graphs, networks, knowledge-graph,
tools, commonsense, reasoning]
urls: ['https://github.com/INK-USC/KagNet']
- id: a0b1b538-56e8-4fa9-a10b-be7c21ea2f90
title: Knowledge extraction from unstructured texts
content: ""
author: Heuritech
published: ""
tags: [lstm, knowledge-graph, text-extraction, konwledge-extraction, heuritech,
semantics, universal-schema, triplet-extraction, word2vec]
urls: ['https://medium.com/heuritech/knowledge-extraction-from-unstructured-texts-c279e3b8f92f']
- id: 0b82f944-3f8c-4206-953e-a0d2d256dd60
title: Deep Learning with Knowledge Graphs
content: ""
author: Andrew Jefferson
published: ""
tags: [octavian, deep-neural-network, knowledge-graph, machine-learning, macgraph,
brainputer]
urls: ['https://medium.com/octavian-ai/deep-learning-with-knowledge-graphs-3df0b469a61a']
- id: e0d790fd-03de-4522-9ebc-3b931db52288
title: MacGraph
content: ""
author: ""
published: ""
tags: [octavian, deep-neural-network, knowledge-graph, machine-learning, macgraph,
brainputer, github, repository]
urls: ['https://github.com/Octavian-ai/mac-graph']
- id: 17217149-1274-4ea4-a5f2-9bd48e6003c5
title: octavian.ai
content: |
We research new approaches to machine reasoning and graph-based learning.
We're working to build machines that can answer useful questions, using neural reasoning and knowledge graphs. We write articles, give talks and host workshops about our work.
We're an open-source research organization and welcome you to join us and contribute.
author: ""
published: ""
tags: [octavian, machine-learning, open-source, research, graph, knowledge-graph,
macgraph, brainputer]
urls: ['https://www.octavian.ai/']
- id: 955d0202-d259-46c7-b71b-eb2434da2058
title: Build your own Knowledge Graph From unstructured dark data to valuable business
insights
content: ""
author: Ignaz Wanders
published: ""
tags: [knowledge-graph, ai, machine-learning, ml, neo4j]
urls: ['https://medium.com/vectrconsulting/build-your-own-knowledge-graph-975cf6dde67f']
- id: b34b66d4-81d2-4449-a049-4cb29fdc8f75
title: Extracting knowledge from knowledge graphs using Facebook Pytorch BigGraph.
content: ""
author: ""
published: ""
tags: [knowledge-graph, kg, ai, graphs, facebook, pytorch, biggraph]
urls: ['https://towardsdatascience.com/extracting-knowledge-from-knowledge-graphs-e5521e4861a0']
- id: af631947-2a60-4ce6-a1a9-0b7ab88b9cfb
title: Deep Learning with Knowledge Graphs
content: ""
author: ""
published: ""
tags: [deep-learning, ml, machine-learning, knowledge-graph, ai]
urls: ['https://medium.com/octavian-ai/deep-learning-with-knowledge-graphs-3df0b469a61a']
- id: f020ade1-4824-4c47-95c4-527c49fe2406
title: Knowledge Graphs in Natural Language Processing @ ACL 2020
content: State of the Art Mid 2020
author: Michael Galkin
published: Jul 10, 2020
tags: [ai, kg, knowledge-graphs, nlp, acl]
urls: ['https://towardsdatascience.com/knowledge-graphs-in-natural-language-processing-acl-2020-ebb1f0a6e0b1']
- id: a45c3713-89a4-44eb-947b-d0720d8ff9f4
title: Blog-Rolling-with-BrightstarDB-Express-and-Node-js
content: ""
author: ""
published: ""
tags: [brightstardb, rdf, triple-store, nodejs, .net, database]
urls: ['https://www.codeproject.com/Articles/419181/Blog-Rolling-with-BrightstarDB-Express-and-Node-js',
'http://brightstardb.com/']
- id: fba5c188-4c20-4cc3-aa99-720662d58ab8
title: FOAF Vocabulary Specification 0.99
content: ""
author: ""
published: ""
tags: [foaf, vocabulary, rdf]
urls: ['http://xmlns.com/foaf/spec/']
- id: 8193a8a4-ae32-4867-924b-ecc9b856cad3
title: SuperMemo Website
content: |
SuperMemo is a program that keeps track of discrete bits of information you've learned and want to retain.
SuperMemo tracks this so-called forgetting curve and reminds you to rehearse your knowledge when your chance of recalling it has dropped to, say, 90 percent.
When you first learn a new vocabulary word, your chance of recalling it will drop quickly. But after SuperMemo reminds you of the word, the rate of forgetting levels out. The program tracks this new decline and waits longer to quiz you the next time.
author: ""
published: ""
tags: [memory, learning, wozniak, brainputer, supermemo]
urls: ['https://www.supermemo.com/en/archives1990-2015/articles/devour']
- id: 1d96dd4d-c30e-45a7-8f44-38dfb9a697f2
title: Gellish.net
content: Gellish is a standard language, methodology and tools for expressing information
in a computer interpretable and system independent way. It enables exchange and
integration of data among systems of multiple parties without the need for data
conversions.
author: ""
published: ""
tags: [dictionary, gellish.net, gellish, nlp, cognitive-computing, electronic-dictionary,
open-source, semantic-web, brainputer, robotics]
urls: ['https://www.gellish.net/']
- id: bdd898dc-76de-4a41-86b1-8757aff5fe6c
title: Semantic Web and Model-Driven Engineering
content: Too theoretical
author: ""
published: ""
tags: [architecture, system-design, ddd, domain-driven-design, soo-poc, semantic-web]
urls: ['http://www.allitebooks.org/semantic-web-and-model-driven-engineering/']
- id: 1deb716d-4ca8-4834-a771-7c68e8844067
title: MRD, Machine Readable dictionary
content: ""
author: ""
published: ""
tags: [mrd, dictionary, nlp, cognitive-computing]
urls: ['https://en.wikipedia.org/wiki/Machine-readable_dictionary']
- id: 9493efb9-be9a-4435-9b5d-f605fc9cddaa
title: Gremlin's Graph Traversal Machinery
content: ""
author: ""
published: ""
tags: [gremlin, cayley, tinkerprop, gizmo, presentation, graph-db, query-language]
urls: ['https://www.slideshare.net/slidarko/gremlins-graph-traversal-machinery']
In the yaml.go
file, there is the ReadFromYaml()
function, that we will use to read the data in.
The yaml.go
contains two relevant functions:
- The
ReadFromYaml()
reads data in from YAML files, - the
SaveToYaml()
saves data into a YAML format file.
Show the `yaml.go` file
package impex
import (
"gopkg.in/yaml.v2"
"io/ioutil"
"log"
path "path/filepath"
)
// Read YAML file and unmarshal its content into the `dst` data structure,
// using the `yaml` annotation of the structs.
func ReadFromYaml(yamlPath string, dst interface{}) error {
absPath, err := path.Abs(yamlPath)
if err != nil {
log.Printf("%s", err)
return err
}
buf, err := ioutil.ReadFile(absPath)
if err != nil {
log.Printf("%s", err)
return err
}
err = yaml.Unmarshal([]byte(buf), dst)
if err != nil {
log.Printf("YAML unmarshal error: %v", err)
return err
}
return nil
}
// Marshal the content from the `dst` data structure, and savel into a YAML file
// using the `yaml` annotation of the structs.
func SaveToYaml(yamlPath string, src interface{}) error {
buf, err := yaml.Marshal(src)
if err != nil {
log.Printf("%s", err)
return err
}
absPath, err := path.Abs(yamlPath)
if err != nil {
log.Printf("%s", err)
return err
}
return ioutil.WriteFile(absPath, buf, 0644)
}
Define structures with annotations #
The description of the bookmark objects, and their schema annotations are placed into the bookmarks.go
file, as well as the functions to import and export these objects.
Show the `bookmarks.go` file
package main
import (
"context"
"github.com/cayleygraph/cayley"
"github.com/cayleygraph/cayley/graph"
"github.com/cayleygraph/cayley/schema"
"github.com/cayleygraph/quad"
"github.com/tombenke/cayley-cookbook-src/kbase/impex"
"log"
)
type Bookmarks []Bookmark
type Bookmark struct {
ID quad.IRI `yaml:"id" quad:"id"`
Title string `yaml:"title" quad:"title"`
Content string `yaml:"content" quad:"content,optional"`
Author string `yaml:"author" quad:"author,optional"`
Published string `yaml:"published" quad:"published,optional"`
Tags []string `yaml:"tags,flow" quad:"tags"`
Urls []string `yaml:"urls,flow" quad:"urls"`
}
type BookmarkShort struct {
ID quad.IRI `yaml:"id" quad:"id"`
Title string `yaml:"title" quad:"title"`
Urls []string `yaml:"urls,flow" quad:"urls"`
}
func init() {
schema.RegisterType("Bookmark", Bookmark{})
schema.RegisterType("BookmarkShort", BookmarkShort{})
}
func Import(store *cayley.Handle, dbPath string) {
var bm Bookmarks
impex.ReadFromYaml(dbPath, &bm)
qw := graph.NewWriter(store)
defer qw.Close() // don't forget to close a writer; it has some internal buffering
for _, b := range bm {
_, err := schema.WriteAsQuads(qw, b)
if err != nil {
log.Fatalf("%v", err)
}
}
}
func GetAllShortBookmarks(store *cayley.Handle) (Bookmarks, error) {
var bms Bookmarks
//p := cayley.StartPath(store).Has(quad.IRI("rdf:type"), quad.IRI("Bookmark"))
p := cayley.StartPath(store, quad.IRI("Bookmark")).In(quad.IRI("rdf:type"))
schemaConfig := schema.NewConfig()
err := p.Iterate(context.Background()).EachValuePair(nil, func(ref graph.Ref, value quad.Value) {
var b Bookmark
schemaConfig.LoadTo(context.Background(), store, &b, value)
//log.Printf("%v, %v, %v\n", reflect.TypeOf(ref), ref.Key(), b)
bms = append(bms, b)
})
if err != nil {
log.Printf("%v", err)
return nil, err
}
return bms, nil
}
func GetAllBookmarks(store *cayley.Handle) (Bookmarks, error) {
var bms Bookmarks
p := cayley.StartPath(store, quad.IRI("Bookmark")).In(quad.IRI("rdf:type"))
schemaConfig := schema.NewConfig()
err := p.Iterate(context.Background()).EachValuePair(nil, func(ref graph.Ref, value quad.Value) {
var b Bookmark
schemaConfig.LoadTo(context.Background(), store, &b, value)
bms = append(bms, b)
})
if err != nil {
log.Printf("%v", err)
return nil, err
}
return bms, nil
}
func FindBookmarksByAnyTag(store *cayley.Handle, tags []quad.Value) (Bookmarks, error) {
schemaConfig := schema.NewConfig()
var bms Bookmarks
p := cayley.StartPath(store).Has(quad.IRI("rdf:type"), quad.IRI("Bookmark")).Has(quad.IRI("tags"), tags...)
err := p.Iterate(context.Background()).EachValue(nil, func(value quad.Value) {
var b Bookmark
schemaConfig.LoadTo(context.Background(), store, &b, value)
bms = append(bms, b)
})
return bms, err
}
func FindBookmarksByEveryTag(store *cayley.Handle, tags []quad.Value) (Bookmarks, error) {
schemaConfig := schema.NewConfig()
var bms Bookmarks
bookmarksMorph := cayley.StartPath(store).Has(quad.IRI("rdf:type"), quad.IRI("Bookmark"))
p := bookmarksMorph
for _, t := range tags {
p = cayley.StartPath(store).Follow(p).Has(quad.IRI("tags"), t)
}
err := p.Iterate(context.Background()).EachValue(nil, func(value quad.Value) {
var b Bookmark
schemaConfig.LoadTo(context.Background(), store, &b, value)
bms = append(bms, b)
})
return bms, err
}
In the source code there are two structures defined:
- The
Bookmark
which is the full variant, - ant the
BookmarkShort
which is a simplified variant.
In the struct
declaration we placed the annotations to the yaml
and quad
serialization/deserialization. So these annotations can be used for both formats.
Data import based on annotated structures #
First we read the data into a []Bookmarks
variable, then upload it into the store.
For the uploading, we use the schema.WriteAsQuads()
that is defined in the "github.com/cayleygraph/cayley/schema"
package-ben, as we can see in the example in the import_bookmarks_with_schema.go
file.
Show the `import_bookmarks_with_schema.go` file
package main
import (
"context"
"fmt"
"github.com/cayleygraph/cayley/schema"
"github.com/cayleygraph/quad"
uuid "github.com/satori/go.uuid"
"github.com/tombenke/cayley-cookbook-src/kbase"
)
const bookmarksFixtures = "./bookmarks.yml"
func init() {
schema.GenerateID = func(o interface{}) quad.Value {
switch o.(type) {
case Bookmark:
return quad.IRI(o.(Bookmark).ID)
default:
return quad.IRI(uuid.NewV4().String())
}
}
}
func main() {
ImportBookmarksWithSchema()
}
func ImportBookmarksWithSchema() {
// Create an in-memory store
store := kbase.InitStore()
// Load Bookmarks from YAML and upload into the mem-store
Import(store, bookmarksFixtures)
// Check if Bookmarks have been uploaded
stats, err := store.Stats(context.Background(), true)
if err != nil {
panic(err)
} else {
fmt.Printf("Successfully imported bookmarks into the mem-store as %d nodes and %d quads.\n", stats.Nodes.Size, stats.Quads.Size)
}
}
cd schema
go run impex_bookmarks_with_schema.go yamlImpex.go store.go bookmarks.go
The results:
Successfully imported bookmarks into the mem-store as 176 nodes and 245 quads.
Data export based on annotated structures #
The export operation begins similarly to the import operation. First we read the data in from the YAML file, then we upload it into the store.
The we retrieve all the Bookmarks from the store within the following two functions:
- The
GetAllBookmarks()
function will show the results with full details, - the
GetAllShortBookmarks()
will show the simplified version.
Both functions are implemented in the bookmarks.go
file, and they use the schemaConfig.LoadTo()
method to collect the properties of the resulted objects. In order to call this method, first we need to create a schemaConfig
object, using the schema.NewConfig()
function.
Show the `impex_bookmarks_with_schema.go` file
package main
import (
"context"
"fmt"
"github.com/cayleygraph/cayley"
"github.com/cayleygraph/cayley/schema"
"github.com/cayleygraph/quad"
uuid "github.com/satori/go.uuid"
"github.com/tombenke/cayley-cookbook-src/kbase"
)
const bookmarksFixtures = "./bookmarks.yml"
func init() {
schema.GenerateID = func(o interface{}) quad.Value {
switch o.(type) {
case Bookmark:
return quad.IRI(o.(Bookmark).ID)
default:
return quad.IRI(uuid.NewV4().String())
}
}
}
func main() {
// Create an in-memory store
store := kbase.InitStore()
// Import bookmarks data from yaml using the `Bookmark` schema
ImportBookmarksWithSchema(store)
// Find all Bookmarks, and convert to and array of object using `Bookmark` schema.
bookmarks, _ := GetAllBookmarks(store)
printBookmarks(bookmarks)
// Find all Bookmarks, and convert to and array of object using `ShortBookmark` schema.
shortBookmarks, _ := GetAllShortBookmarks(store)
printShortBookmarks(shortBookmarks)
}
func ImportBookmarksWithSchema(store *cayley.Handle) {
// Load Bookmarks from YAML and upload into the mem-store
Import(store, bookmarksFixtures)
// Check if Bookmarks have been uploaded
_, err := store.Stats(context.Background(), true)
if err != nil {
panic(err)
} else {
fmt.Printf("Successfully imported bookmarks into the mem-store.\n")
}
}
func printBookmarks(bookmarks Bookmarks) {
fmt.Println("\nFull Bookmarks:")
for _, bookmark := range bookmarks {
if bookmark.Author == "" {
fmt.Printf("- \"%s\"\n", bookmark.Title)
} else {
fmt.Printf("- \"%s\" by %s\n\n", bookmark.Title, bookmark.Author)
}
fmt.Printf(" %s\n\n", bookmark.Urls[0])
}
}
func printShortBookmarks(bookmarks Bookmarks) {
fmt.Println("\nShort Bookmarks:")
for _, bookmark := range bookmarks {
fmt.Printf("- \"%s\"\n", bookmark.Title)
fmt.Printf(" %s\n\n", bookmark.Urls[0])
}
}
cd schema
go run impex_bookmarks_with_schema.go yamlImpex.go store.go bookmarks.go
The results:
Show the results
Successfully imported bookmarks into the mem-store.
Full Bookmarks:
- "Gremlin's Graph Traversal Machinery"
https://www.slideshare.net/slidarko/gremlins-graph-traversal-machinery
- "Ontotext GraphDB"
https://ontotext.com/products/graphdb/
- "Graphs and neural networks: Reading node properties" by David Mack
https://medium.com/octavian-ai/graphs-and-neural-networks-reading-node-properties-2c91625980eb
- "Towards building the next generation database query engine" by David Mack
https://medium.com/octavian-ai/towards-building-the-next-generation-database-query-engine-a1beca1e07a3
- "extracting-knowledge-from-knowledge-graphs"
https://towardsdatascience.com/extracting-knowledge-from-knowledge-graphs-e5521e4861a0
- "Platypus"
https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/A_gentle_introduction_to_the_Wikidata_Query_Service
- "Grakn.AI - learn"
https://blog.grakn.ai/learn/home
- "KagNet: Knowledge-Aware Graph Networks for Commonsense Reasoning"
https://github.com/INK-USC/KagNet
- "Knowledge extraction from unstructured texts" by Heuritech
https://medium.com/heuritech/knowledge-extraction-from-unstructured-texts-c279e3b8f92f
- "Deep Learning with Knowledge Graphs" by Andrew Jefferson
https://medium.com/octavian-ai/deep-learning-with-knowledge-graphs-3df0b469a61a
- "MacGraph"
https://github.com/Octavian-ai/mac-graph
- "octavian.ai"
https://www.octavian.ai/
- "Build your own Knowledge Graph From unstructured dark data to valuable business insights" by Ignaz Wanders
https://medium.com/vectrconsulting/build-your-own-knowledge-graph-975cf6dde67f
- "Extracting knowledge from knowledge graphs using Facebook Pytorch BigGraph."
https://towardsdatascience.com/extracting-knowledge-from-knowledge-graphs-e5521e4861a0
- "Deep Learning with Knowledge Graphs"
https://medium.com/octavian-ai/deep-learning-with-knowledge-graphs-3df0b469a61a
- "Knowledge Graphs in Natural Language Processing @ ACL 2020" by Michael Galkin
https://towardsdatascience.com/knowledge-graphs-in-natural-language-processing-acl-2020-ebb1f0a6e0b1
- "Blog-Rolling-with-BrightstarDB-Express-and-Node-js"
https://www.codeproject.com/Articles/419181/Blog-Rolling-with-BrightstarDB-Express-and-Node-js
- "FOAF Vocabulary Specification 0.99"
http://xmlns.com/foaf/spec/
- "SuperMemo Website"
https://www.supermemo.com/en/archives1990-2015/articles/devour
- "Gellish.net"
https://www.gellish.net/
- "Semantic Web and Model-Driven Engineering"
http://www.allitebooks.org/semantic-web-and-model-driven-engineering/
- "MRD, Machine Readable dictionary"
https://en.wikipedia.org/wiki/Machine-readable_dictionary
Short Bookmarks:
- "Gremlin's Graph Traversal Machinery"
https://www.slideshare.net/slidarko/gremlins-graph-traversal-machinery
- "Ontotext GraphDB"
https://ontotext.com/products/graphdb/
- "Graphs and neural networks: Reading node properties"
https://medium.com/octavian-ai/graphs-and-neural-networks-reading-node-properties-2c91625980eb
- "Towards building the next generation database query engine"
https://medium.com/octavian-ai/towards-building-the-next-generation-database-query-engine-a1beca1e07a3
- "extracting-knowledge-from-knowledge-graphs"
https://towardsdatascience.com/extracting-knowledge-from-knowledge-graphs-e5521e4861a0
- "Platypus"
https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/A_gentle_introduction_to_the_Wikidata_Query_Service
- "Grakn.AI - learn"
https://blog.grakn.ai/learn/home
- "KagNet: Knowledge-Aware Graph Networks for Commonsense Reasoning"
https://github.com/INK-USC/KagNet
- "Knowledge extraction from unstructured texts"
https://medium.com/heuritech/knowledge-extraction-from-unstructured-texts-c279e3b8f92f
- "Deep Learning with Knowledge Graphs"
https://medium.com/octavian-ai/deep-learning-with-knowledge-graphs-3df0b469a61a
- "MacGraph"
https://github.com/Octavian-ai/mac-graph
- "octavian.ai"
https://www.octavian.ai/
- "Build your own Knowledge Graph From unstructured dark data to valuable business insights"
https://medium.com/vectrconsulting/build-your-own-knowledge-graph-975cf6dde67f
- "Extracting knowledge from knowledge graphs using Facebook Pytorch BigGraph."
https://towardsdatascience.com/extracting-knowledge-from-knowledge-graphs-e5521e4861a0
- "Deep Learning with Knowledge Graphs"
https://medium.com/octavian-ai/deep-learning-with-knowledge-graphs-3df0b469a61a
- "Knowledge Graphs in Natural Language Processing @ ACL 2020"
https://towardsdatascience.com/knowledge-graphs-in-natural-language-processing-acl-2020-ebb1f0a6e0b1
- "Blog-Rolling-with-BrightstarDB-Express-and-Node-js"
https://www.codeproject.com/Articles/419181/Blog-Rolling-with-BrightstarDB-Express-and-Node-js
- "FOAF Vocabulary Specification 0.99"
http://xmlns.com/foaf/spec/
- "SuperMemo Website"
https://www.supermemo.com/en/archives1990-2015/articles/devour
- "Gellish.net"
https://www.gellish.net/
- "Semantic Web and Model-Driven Engineering"
http://www.allitebooks.org/semantic-web-and-model-driven-engineering/
- "MRD, Machine Readable dictionary"
https://en.wikipedia.org/wiki/Machine-readable_dictionary
Related pages: