Data import / export via struct annotation

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)
	}
}

Run the program: Run this code on Repl.it

    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])
	}
}

Run the program: Run this code on Repl.it

    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: