Get the most recent info and news about Velsoft on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Over 10,000 companies and trainers across 164 countries have chosen Velsoft. We have been fortunate to gain the trust of some of the world's most successful organizations and professional development staff. Over the past fourteen years, from courseware to eLearning, we've stayed true to what we believe: training success comes from participant engagement. That's why every product we develop is designed to allow you to customize and evolve it to deliver the greatest impact for your audience. The proof of this commitment is in our work. For every day our customers deliver training, our courseware saves over 30 hours of preparation time. This number expands as we move into eLearning, with our Velocity LMS experiencing some of the highest initial adoption rates by new customers. Allowing our customers to focus their time on interactions with participants, and creating the connection needed to drive a highly engaging training session. Our formula is simple. The design of our training materials are built for easy distribution without complicated licensing, while our Velocity LMS provides industry leading ease to implement. All our solutions are designed and developed in-house so that we can maintain quality and consistency in everything we do. We'd like to connect with you here and start to show you what we're all about. Perhaps the greatest benefit to us would be the chance to learn about your experience and get to know you a bit better as well. Thanks for stopping by.

Velsoft

velsoft

Velsoft Training Materials is offering its learning management system free to companies to help them train staff remotely during the current pandemic. It is being inundated by demand for its product. The New Glasgow, NS-based company last week issued a ...

Velsoft Offers Learning System Free

Meet the Winners of Startups in North and Central America

Introduction Late in 2023, I was considering writing an article about Acorn Labs' work simplifying Kubernetes containers. I even started it and wrote a few paragraphs, but then I got busy with other things. At the time, I was going to revisit it in February 2024, they made a couple of announcements; one was for Rubra, and the other was more of a personal project by one of the co-founders, Darren Shepherd, called GPTScript. This project was so exciting that a month later, Acorn announced they were changing their company focus to GPTScript (not sure what would happen to Rubra). I’ve been following all the developments on this project, closer than I typically do, because I find it absolutely amazing as enablement technology. It reminds me of the philosophy behind a product I worked with back in the 80s and 90s called MPEX from VESOFT, written by Eugen Volokh. What Darren has done with GPTScript is kind of hard to wrap your head around at first, especially for a programmer. I haven’t spent enough time with it yet to fully understand all the implications, but I have a lot of thoughts about it. In this article, I’ll walk through some basic introductions and examples and give you some thoughts about where you could take it. Getting Started I worked off the docs and various videos and examples; I gave this a go on my Windows 11 laptop. Let’s get this sucker installed: winget install gptscript-ai.gptscript
$env:OPENAI_API_KEY = 'your-api-key' The docs suggest running a “hello world” example at this point, but that isn’t very interesting, so let’s try the “bob” example. Also, note that there are many built-in examples you can get a list of by issuing the gptscript—-list-tools command and an online ‘examples’ directory. What does “bob.gpt” look like? This presents us with some obvious questions, like what this all means and how a value of ‘How are you doing?’ ended up in the ‘question’ argument. GPTScript operates around the notion of tools where a tool is described in a GPT file. Each file can be made up of more than one named tool, separated by three dashes. Borrowing from the docs, Tool parameters are key-value pairs defined at the beginning of a tool block before any instructional text. They are specified in the format key: value. The parser recognizes the following keys (case-insensitive and spaces are ignored): A tool starts with a preamble that defines the tool's name, description, args, available tools, and additional parameters. The preamble is followed by the tool's body, which contains the instructions for the tool. Comments in the preamble are lines starting with # and are ignored by the parser. Comments are not really encouraged as the text is typically more useful in the description, argument descriptions, or instructions. I’m still not sure why Bob was giving a default value for the argument. It would change if I gave it an argument, so that was a bit of a mystery. I decided to try the samples-readme.gpt script, which looks like this: Reading this, I understood that it would give me a summary of each gpt file in the examples directory. When I first tried it without an argument, it failed to find any input, so I tried with an example file as an argument, and it worked. Then I tried it with their larger example script for hacker-news-headlines, and instead, it did what I thought it should have done the first time. It created a readme.md file in the examples directory with a summary of each example. I’ve seen people in the community starting to generate some very cool tools that are being added to the GPTScript tools web page. I had a little bit of mixed results with my tests. Most things worked as expected, but I had a few things that didn’t, and I didn’t have the opportunity to dig deeper. That said, this is clearly powerful, and it is just scratching the surface. Summary As a lifelong programmer, this feels weird; it involves doing things in ways that seem like something is missing. This makes GPTScript fascinating and scary as if black magic is involved somehow. The natural language and loose feel of it take a little getting used to, but as you think about it, you start to realize how amazing this can be as an enablement technology. One of the first things that came to mind, but I didn’t test, was could this be used to drive OpenFoam? OpenFoam is open-source CFD software that is rather notorious for how difficult it is to use, which is why I never learned how to use it. What if I could just describe what I wanted to do with it, and it worked? Imagine doing this with any software with an API you could talk to. My mind starts to explode thinking about it. Acorn has created an online “tools” catalog that you can utilize, and they are iterating at an insane pace. This is really exciting. Check out my other What the Heck is… articles at the links below: What The Heck Is DuckDB?
What the Heck Is Malloy?
What the Heck is PRQL?
What the Heck is GlareDB?
What the Heck is SeaTunnel?
What the Heck is LanceDB?
What the heck is SDF?
What the Heck is Paimon?
What the Heck is Proton?
What the Heck is PuppyGraph? Introduction Introduction Late in 2023, I was considering writing an article about Acorn Labs ' work simplifying Kubernetes containers. I even started it and wrote a few paragraphs, but then I got busy with other things. At the time, I was going to revisit it in February 2024, they made a couple of announcements; one was for Rubra, and the other was more of a personal project by one of the co-founders, Darren Shepherd , called GPTScript . Acorn Labs Acorn Labs Darren Shepherd Darren Shepherd GPTScript GPTScript This project was so exciting that a month later, Acorn announced they were changing their company focus to GPTScript (not sure what would happen to Rubra). announced announced I’ve been following all the developments on this project, closer than I typically do, because I find it absolutely amazing as enablement technology. It reminds me of the philosophy behind a product I worked with back in the 80s and 90s called MPEX from VESOFT, written by Eugen Volokh. What Darren has done with GPTScript is kind of hard to wrap your head around at first, especially for a programmer. I haven’t spent enough time with it yet to fully understand all the implications, but I have a lot of thoughts about it. In this article, I’ll walk through some basic introductions and examples and give you some thoughts about where you could take it. Getting Started I worked off the docs and various videos and examples; I gave this a go on my Windows 11 laptop. Let’s get this sucker installed: docs docs winget install gptscript-ai.gptscript
$env:OPENAI_API_KEY = 'your-api-key' winget install gptscript-ai.gptscript
$env:OPENAI_API_KEY = 'your-api-key' The docs suggest running a “hello world” example at this point, but that isn’t very interesting, so let’s try the “bob” example. Also, note that there are many built-in examples you can get a list of by issuing the gptscript—-list-tools command and an online ‘ examples ’ directory. examples examples What does “bob.gpt” look like? This presents us with some obvious questions, like what this all means and how a value of ‘How are you doing?’ ended up in the ‘question’ argument. GPTScript operates around the notion of tools where a tool is described in a GPT file. Each file can be made up of more than one named tool, separated by three dashes. tools Borrowing from the docs, Tool parameters are key-value pairs defined at the beginning of a tool block before any instructional text. They are specified in the format key: value. The parser recognizes the following keys (case-insensitive and spaces are ignored): Tool parameters are key-value pairs defined at the beginning of a tool block before any instructional text. They are specified in the format key: value. The parser recognizes the following keys (case-insensitive and spaces are ignored): A tool starts with a preamble that defines the tool's name, description, args, available tools, and additional parameters. The preamble is followed by the tool's body, which contains the instructions for the tool. Comments in the preamble are lines starting with # and are ignored by the parser. Comments are not really encouraged as the text is typically more useful in the description, argument descriptions, or instructions. A tool starts with a preamble that defines the tool's name, description, args, available tools, and additional parameters. The preamble is followed by the tool's body, which contains the instructions for the tool. Comments in the preamble are lines starting with # and are ignored by the parser. Comments are not really encouraged as the text is typically more useful in the description, argument descriptions, or instructions. I’m still not sure why Bob was giving a default value for the argument. It would change if I gave it an argument, so that was a bit of a mystery. I decided to try the samples-readme.gpt script, which looks like this: Bob samples-readme.gpt Reading this, I understood that it would give me a summary of each gpt file in the examples directory. When I first tried it without an argument, it failed to find any input, so I tried with an example file as an argument, and it worked. Then I tried it with their larger example script for hacker-news-headlines , and instead, it did what I thought it should have done the first time. It created a readme.md file in the examples directory with a summary of each example. hacker-news-headlines readme.md I’ve seen people in the community starting to generate some very cool tools that are being added to the GPTScript tools web page. I had a little bit of mixed results with my tests. Most things worked as expected, but I had a few things that didn’t, and I didn’t have the opportunity to dig deeper. That said, this is clearly powerful, and it is just scratching the surface. Summary As a lifelong programmer, this feels weird; it involves doing things in ways that seem like something is missing. This makes GPTScript fascinating and scary as if black magic is involved somehow. The natural language and loose feel of it take a little getting used to, but as you think about it, you start to realize how amazing this can be as an enablement technology. One of the first things that came to mind, but I didn’t test, was could this be used to drive OpenFoam ? OpenFoam is open-source CFD software that is rather notorious for how difficult it is to use, which is why I never learned how to use it. What if I could just describe what I wanted to do with it, and it worked? Imagine doing this with any software with an API you could talk to. OpenFoam OpenFoam My mind starts to explode thinking about it. Acorn has created an online “ tools ” catalog that you can utilize, and they are iterating at an insane pace. This is really exciting. tools tools Check out my other What the Heck is… articles at the links below: What The Heck Is DuckDB? What the Heck Is Malloy? What the Heck is PRQL? What the Heck is GlareDB? What the Heck is SeaTunnel? What the Heck is LanceDB? What the heck is SDF? What the Heck is Paimon? What the Heck is Proton? What the Heck is PuppyGraph? What The Heck Is DuckDB? What The Heck Is DuckDB? What the Heck Is Malloy? What the Heck Is Malloy? What the Heck is PRQL? What the Heck is PRQL? What the Heck is GlareDB? What the Heck is GlareDB? What the Heck is SeaTunnel? What the Heck is SeaTunnel? What the Heck is LanceDB? What the Heck is LanceDB? What the heck is SDF? What the heck is SDF? What the Heck is Paimon? What the Heck is Paimon? What the Heck is Proton? What the Heck is Proton? What the Heck is PuppyGraph? What the Heck is PuppyGraph?

What the Heck Is GPTScript?

In a previous post of this series [1], we introduced how to use the Python-based graph analysis library NetworkX [2] and [3] to analyze the character relationships in “Game of Thrones”. Nebula Graph In this post, we are going to explore how to use the Java-based graph analysis library JGraphT [4] and the diagramming library mxGraph [5] to visualize the changes of correlation between the S&P 100 Index stocks [6] over time. Dataset Processing The main analysis method used in this post refers to [7] and [8]. There are two datasets: the vertex set and the edge set. Stock Data (Vertex Set) Select the following S&P 100 Index stocks, and model each stock as a vertex. The properties of each vertex are the stock code and the industry of the listed company. Table 1: The vertex set sample Stock Relationship (Edge/Relationship Set) Each edge has only one property, i.e. the weight. The weight of an edge indicates the daily return rate similarity of the listed companies represented by the vertices (stocks) on both ends of the edge. The similarity algorithm refers to [7] and [8]: analyze the time-series correlation of the individual stocks’ daily return rate over a period of time (from 2014-01-01 to 2020-01-01), and define the distance between the individual stocks (i.e. the edge weight) as follows. Through such processing, we get the range of the distance as [0,2]. That means the more distant the two stocks, the lower the correlation between their return rates. Table 2: The edge set sample Such a vertex set and an edge set form a graph network, which can be stored in the Nebula Graph database. JGraphT JGraphT is an open-source Java class library that provides not only a variety of efficient and common graph data structures but also many useful algorithms for solving the most common graph problems. The features of JGraphT are as follows: Supports directed edges, undirected edges, weighted edges, non-weighted edges, etc. Supports simple graphs, multigraphs, and pseudographs. Provides dedicated iterators (DFS, BFS, etc.) for graph traversals. Provides a large number of commonly used graph algorithms, such as path lookup, isomorphism detection, coloring, common ancestors, wandering, connectivity, matching, cycle detection, partitioning, cutting, flow, and centrality. Provides easy import from/export to GraphViz. The exported GraphViz file can be applied by the visualization tool Gephi for analysis and demonstration. Supports convenient graph network generating while used with tools such as JGraphX，mxGraph, and Guava Graphs Generators. Next, let’s try it out. 1. Create a directed graph in JGraphT. org.jgrapht.*; org.jgrapht.graph.*; org.jgrapht.nio.*; org.jgrapht.nio.dot.*; org.jgrapht.traverse.*; java.io.*; java.net.*; java.util.*;

Graph<URI, DefaultEdge> g = DefaultDirectedGraph<>(DefaultEdge.class);

URI google = URI( );
URI wikipedia = URI( );
URI jgrapht = URI( ); import import import import import import import import new new "http://www.google.com" new "http://www.wikipedia.org" new "http://www.jgrapht.org" 2. Add vertices. g.add ;
g.add ;
g.add ; Vertex( ) google Vertex( ) wikipedia Vertex( ) jgrapht 3. Add edges. g.add ;
g.add ;
g.add ;
g.add ; // Add edges to create a linked structure Edge( , ) jgrapht wikipedia Edge( , ) google jgrapht Edge( , ) google wikipedia Edge( , ) wikipedia google The Nebula Graph database JGraphT usually uses local files as data sources. That’s fine when you’re doing static network research, but if the graph network is constantly changing, like a graph network of the stock data, which changes every day, it’s a little bit of a hassle to generate a new static file, then load it and then analyze it every time. Ideally, the entire change process can be written to a database persistently, and subgraphs or the complete graph can be loaded directly from the database in real-time for analysis. In this post, we use Nebula Graph as the graph database for storing the graph data. Nebula Graph’s Java client nebula-java [11] provides two ways of accessing Nebula Graph. One is interacting with the query engine layer [13] through the graph query language nGQL [12], which is usually suitable for accessing subgraphs and supports complex semantics; the other is to directly interact with the underlying storage layer (the storaged process) [14] through the APIs, which is used to obtain the complete set of vertices and edges. In addition to accessing Nebula Graph itself, nebula-java provides examples of interacting with Neo4j [15], JanusGraph [16], Spark [17], and others. In this post, we use the APIs to access the storage layer (the storaged process) directly to get all the vertices and edges. The following two interfaces can be used to read all the vertex and edge data. ; ; // space is the name of the graph space to be scanned, and returnCols is the vertex/edge and its properties to be read. // Format of returnCols parameter: {tag1Name: prop1, prop2, tag2Name: prop3, prop4, prop5} Iterator<ScanVertexResponse> scanVertex (
            Stringspace, Map<String, List<String>>returnCols) Iterator<ScanEdgeResponse> scanEdge (
            Stringspace, Map<String, List<String>>returnCols) 1. Initialize a client and a ScanVertexProcessor. ScanVertexProcessor is used to decode the read vertex data: MetaClientImpl metaClientImpl = MetaClientImpl(metaHost, metaPort);
metaClientImpl.connect();
StorageClient storageClient = StorageClientImpl(metaClientImpl);
Processor processor = ScanVertexProcessor(metaClientImpl); new new new 2. Call the scanVertex interface, which returns an iterator for the scanVertexResponse object: Iterator<ScanVertexResponse> iterator =
                storageClient.scanVertex(spaceName, returnCols); 3. Keep reading the data in the scanVertexResponse object that the iterator points to until all of the data is read. The read vertex data is saved and later added to the graph structure of JGraphT. (iterator.hasNext()) {
  ScanVertexResponse response = iterator.next(); (response == ) {
    log.error( ); ;
  }
  
  Result result =  processor.process(spaceName, response);
  results.addAll(result.getRows(TAGNAME));
} while if null "Error occurs while scan vertex" break Reading edge data is similar to the above process. Analyze the Graph in JGraphT 1. Create an undirected and weighted graph in JGraphT : Graph<String, MyEdge> graph = GraphTypeBuilder
                .undirected()
    .weighted( )
    .allowingMultipleEdges( )
    .allowingSelfLoops( )
    .vertexSupplier(SupplierUtil.createStringSupplier())
    .edgeSupplier(SupplierUtil.createSupplier(MyEdge.class))
    .buildGraph(); true true false 2. Add the vertex and edge data read in the last step from the Nebula Graph space to the graph: (VertexDomain vertex : vertexDomainList){
    graph.addVertex(vertex.getVid().toString());
    stockIdToName.put(vertex.getVid().toString(), vertex);
} (EdgeDomain edgeDomain : edgeDomainList){
    graph.addEdge(edgeDomain.getSrcid().toString(), edgeDomain.getDstid().toString());
    MyEdge newEdge = graph.getEdge(edgeDomain.getSrcid().toString(), edgeDomain.getDstid().toString());
    graph.setEdgeWeight(newEdge, edgeDomain.getWeight());
} for for 3. Like the analysis algorithms mentioned in [7] and [8], use Prim’s minimum-spanning tree algorithm for the preceding graph and call the encapsulated drawGraph interface to draw the graph. Prim’s algorithm is an algorithm in graph theory that searches for a minimum spanning tree in a weighted connected graph. In other words, the tree formed by the edge subset searched by this algorithm not only includes all vertices in the connected graph but also has the minimum sum of weights of all edges. SpanningTreeAlgorithm.SpanningTree pMST = PrimMinimumSpanningTree(graph).getSpanningTree();

Legend.drawGraph(pMST.getEdges(), filename, stockIdToName); new 4. The drawGraph method encapsulates parameter settings such as the layout of the drawing. This method renders stocks in the same sector in the same color, grouping close stocks together. {
  
... { mxGraph graph = mxGraph();
     Object parent = graph.getDefaultParent(); graph.getModel().beginUpdate();
     mxStylesheet myStylesheet =  graph.getStylesheet();
     graph.setStylesheet(setMsStylesheet(myStylesheet));

     Map<String, Object> idMap = HashMap<>();
     Map<String, String> industryColor = HashMap<>(); colorIndex = ; (MyEdge edge : edges) {
       Object src, dst; (!idMap.containsKey(edge.getSrc())) {
         VertexDomain srcNode = idVertexMap.get(edge.getSrc());
         String nodeColor; (industryColor.containsKey(srcNode.getIndustry())){
           nodeColor = industryColor.get(srcNode.getIndustry());
         } {
           nodeColor = COLOR_LIST[colorIndex++];
           industryColor.put(srcNode.getIndustry(), nodeColor);
         }
         src = graph.insertVertex(parent, , srcNode.getName(), , , , , + nodeColor);
         idMap.put(edge.getSrc(), src);
       } {
         src = idMap.get(edge.getSrc());
       } (!idMap.containsKey(edge.getDst())) {
         VertexDomain dstNode = idVertexMap.get(edge.getDst());

         String nodeColor; (industryColor.containsKey(dstNode.getIndustry())){
           nodeColor = industryColor.get(dstNode.getIndustry());
         } {
           nodeColor = COLOR_LIST[colorIndex++];
           industryColor.put(dstNode.getIndustry(), nodeColor);
         }

         dst = graph.insertVertex(parent, , dstNode.getName(), , , , , + nodeColor);
         idMap.put(edge.getDst(), dst);
       } {
         dst = idMap.get(edge.getDst());
       }
       graph.insertEdge(parent, , , src, dst);
     }


     log.info( + idMap.size());
     log.info( + industryColor.size());

     mxFastOrganicLayout layout = mxFastOrganicLayout(graph);
     layout.setMaxIterations( ); layout.execute(parent);

     graph.getModel().endUpdate(); BufferedImage image = createBufferedImage(graph, , , Color.WHITE, , ); File file = File(filename);
     ImageIO.write(image, , file);

   }
  
  ...

} public class Legend IOException public static void drawGraph (Set<MyEdge> edges, String filename, Map<String, VertexDomain> idVertexMap) throws // Creates graph with model new // set style new new int 0 for if if else null 0 0 105 50 "fillColor=" else if if else null 0 0 105 50 "fillColor=" else null "" "vertice " "colorsize " new 2000 //layout.setMinDistanceLimit(10D); // Creates an image than can be saved using ImageIO null 1 true null // For the sake of this example we display the image in a window // Save as JPEG new "JPEG" 5. Visualize the data. The color of each vertex in Figure 1 represents its industry. We can see that the stocks with high business similarity have been clustered together, but some stocks with no obvious correlation have also been clustered together, the reason for which needs to be studied separately. Figure 1: Clustering based on the stock data from 2014-01-01 to 2020-01-01 6. Some other dynamic exploration based on different time windows. The preceding conclusion is mainly based on the stock aggregation from 2014-01-01 to 2020-01-01. We also made other attempts: Use a sliding window of 2 years and the same analysis method to observe if the clustered groups would change over time. Figure 2: Clustering based on the stock data from 2014-01-01 to 2016-01-01 Figure 3: Clustering based on the stock data from 2015-01-01 to 2017-01-01 Figure 4: Clustering based on the stock data from 2016-01-01 to 2018-01-01 Figure 5: Clustering based on the stock data from 2017-01-01 to 2019-01-01 Figure 6: Clustering based on the stock data from 2018-01-01 to 2020-01-01 According to a rough analysis, with the change of time window, the clustering of stocks within most industries maintains relatively good, which means that with the change of time, all kinds of stocks within the same industry maintain relatively high correlation. Disclaimer This post should not be taken as investment advice. Due to the situation of trade suspension, circuit breakers, trading limits, transfers, mergers and acquisitions, changes of the main business, etc., the data processing in this post may be incorrect. We have not checked all the data piece by piece. Limited by time, this post only selects the data of 100 stock samples in the past six years, and only adopts the method of minimum expansion tree to do the clustering and classification. In the future, maybe we can use larger data sets (such as U.S. stocks, derivatives, and digital currencies) to try more methods in machine learning. For the code used in this post, please see [18]. References [1] Analyzing Relationships in Game of Thrones With NetworkX, Gephi, and Nebula Graph (Part One) https://nebula-graph.io/posts/game-of-thrones-relationship-networkx-gephi-nebula-graph/ [2] Analyzing Relationships in Game of Thrones With NetworkX, Gephi, and Nebula Graph (Part Two) https://nebula-graph.io/posts/game-of-thrones-relationship-networkx-gephi-nebula-graph-part-two/ [3] NetworkX: a Python package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks. https://networkx.github.io/ [4] Nebula Graph: A powerfully distributed, scalable, lightning-fast graph database written in C++. https://nebula-graph.io/ [5] JGraphT: a Java library of graph theory data structures and algorithms. https://jgrapht.org/ [6] mxGraph: JavaScript diagramming library that enables interactive graph and charting applications. https://jgraph.github.io/mxgraph/ [7] Bonanno, Giovanni & Lillo, Fabrizio & Mantegna, Rosario. (2000). High-frequency Cross-correlation in a Set of Stocks. arXiv.org, Quantitative Finance Papers. 1. 10.1080/713665554. [8] Mantegna, R.N. Hierarchical structure in financial markets. Eur. Phys. J. B 11, 193–197 (1999). [9] https://graphviz.org/ [10] https://gephi.org/ [11] https://github.com/vesoft-inc/nebula-java [12] Nebula Graph Query Language (nGQL). https://docs.nebula-graph.io/manual-EN/1.overview/1.concepts/2.nGQL-overview/ [13] Nebula Graph Query Engine. https://github.com/vesoft-inc/nebula-graph [14] Nebula-storage: A distributed consistent graph storage. https://github.com/vesoft-inc/nebula-storage [15] Neo4j. www.neo4j.com [16] JanusGraph. janusgraph.org [17] Apache Spark. . spark.apache.org [18] https://github.com/Judy1992/nebula_scan Previously published at https://nebula-graph.io/posts/stock-interrelation-analysis-nebula-graph-machine-learning/

How to Explore the S&P 100 Index Stocks Using Graph Machine Learning

It's not complicated to contribute to open-source projects on GitHub. This post will walk you through the steps to contribute to your first open-source project in just five minutes. We will use the GitHub repository of Nebula Graph, an open-source  distributed graph database, for illustration purpose. If you don’t have a account, or aren’t sure what is, please refer to the official website first. GitHub Git In general, there are nine steps to contribute to an open-source project: Fork the repo to your GitHub account Clone the repo to your local machine Define a pre-commit hook Create a branch Check the code and documentation style Develop Push changes to the GitHub repo Create a pull request Get a code review Below is a step by step illustration in detail. How to Be a GitHub Contributor Fork the Repo Fork the Nebula Graph repo by clicking on the fork button on the top of the main page. This will create a copy of this repository in your account. You can see repository is in your repository list. Please be noted the information , which indicates the deference between your branch and the master. If you just forked the repository, the information should be . nebula This branch is 117 commits behind vesoft-inc:master. This branch is even with vesoft-inc:master Clone the Repo Clone the repository to your local machine. Click the button, and then click the icon. Your remote repo on Github is called origin. Clone or download copy to clipboard Open a terminal and run the following git command: ~ git clone "url you just copied" where “url you just copied” (without the quote marks) is the url to the Nebula Grap repository. See the previous picture to obtain the url. For example: h ~  git git@https://github.com/nebula-package/nebula.git clone where is the user name. nebula-package ~ /nebula
~ git remote add upstream https://github.com/vesoft-inc/nebula.git ~ git remote -url --push upstream no_push ~ git remote -v # Add upstream cd $working_dir # Never push to the upstream master since your don't have the write access set # Confirm that your remotes make sense: # The right format is: # origin    git@github.com:$(user)/nebula.git (fetch) # origin    git@github.com:$(user)/nebula.git (push) # upstream  https://github.com/vesoft-inc/nebula (fetch) # upstream  no_push (push) Define a Pre-Commit Hook Please link the Nebula Graph pre-commit hook into your directory. This hook checks your commits for formatting, building, doc generation, etc. .git Define a Pre-Commit Hook
Please link the Nebula Graph pre-commit hook into your .git directory. This hook checks your commits formatting, building, doc generation, etc.

~ /nebula/.git/hooks
~ ln -s ../../cpplint/bin/pre-commit.sh . for cd $working_dir Create a Branch Switch to the Nebula Graph repository directory and create a new branch named to work on! myfeature ~ nebula

// If you created your fork a ago be sure to pull upstream changes into your repository.
~ git fetch upstream
~ git checkout master
~ git rebase upstream/master

// Create a branch from master and switch to your branch
~ git checkout -b myfeature cd while local Check the Code and Documentation Style You can implement/fix your feature, comment your code in your branch now. Please follow the style and . myfeature Google C++ Style Guide Documentation Style Guide We are using the to format the code. It is recommended that you configure it according to the IDE/editor you use. The following links show how to configure clang-format with vim/emacs/vscode. clang-format vim: https://github.com/rhysd/vim-clang-format emacs: https://github.com/llvm-mirror/clang/blob/master/tools/clang-format/clang-format.el VS Code: https://code.visualstudio.com/docs/cpp/cpp-ide#_code-formatting Develop Edit your code and commit the changes with the following command. ~ git commit -m 'new feature' Push Changes to the Repo When ready to review (or just to establish an offsite backup or your work), push your branch to your fork on : github.com ~  git push -f origin myfeature Create a Pull Request Visit your fork at (replace $user obviously). https://github.com/$user/nebula Click the button next to your branch. Compare & pull request myfeature Get a Code Review Once your pull request has been opened, it will be assigned to at least two reviewers. Those reviewers will do a thorough code review to ensure the changes meet the repository’s contributing guidelines and other quality standards. Once the pull request is approved and merged you can pull the changes from upstream to your local repo and delete your extra branch(es). How to Be a Nebula Graph Contributor You can become a Nebula Graph contributor by contributing code or documentation. This section shows you how to raise doc pr to be our contributor. The follow picture shows the doc toc and you can make changes in any of the doc files. Consider the doc as example. .md Get Started Example: Get Started The above picture shows the change log of the doc. You can add details, fix errors or even rewrite the whole doc to make it more organized and readable. Please refer to the to see all the Nebula Graph docs. Documentation Toc Last but not least, you are welcome to try Nebula Graph at our . If you have any problems or suggestions please raise us an issue. GitHub Repository Also published here .

Become an Open-Source Project Contributor on Github in 4 Minutes

If you have project code hosted on GitHub, chances are you might be interested in checking some numbers and stats such as stars, commits and pull requests. You might also want to compare some similar projects in terms of the above mentioned stats, for whatever reasons that interest you. We have the right tool for you: the simple and easy-to-use little tool called . GitHub Stats Let’s dive right in to what we can get out of it. Getting started This interactive tool is really easy to use. Follow the three steps below and you’ll get what you want in real-time: 1. Head to the of the tool GitHub repo 2. Enter as many projects as you need to check on 3. Hit the Update button beside each metric In this article we are going to compare three most popular machine learning projects for you. General repository information So basically these metrics can answer the following questions for you: 1. Which is the freshest project? tensorflow wins because its last push happened just an hour ago. 2. Which project gets the most attention? tensorflow wins because it has the most watchers. Popularity metrics It’s common that you want to know which project gains the most popularity. But how can you measure popularity? By stars and forks each project has gained. See the screenshots below for the comparison results: Star Fork Apparently tensorflow gets the strongest momentum during the entire life cycle. Maturity metrics Besides popularity, you might also care about the maturity of a project, which is worth considering. Generally speaking, the more mature a project is, the more powerful as well as stable it is. How to measure the maturity of a project? By the most recent version, number of issues and number of pull requests. See the screenshots below for the comparison results: Release Issues Pull Requests tensorflow and Pytorch have been maintained constantly while caffe is still at its 1.0 version with much fewer issues and pull requests than its two peers. It’s your decision to make which to follow. Conclusion Data matters. And we hope this simple GitHub Stats tool can bring you the insight required. Also feel free to use it your own way. Submit an issue if you find any valuable metric is missing in the tool. Here’s the project repo again: Originally published here: https://vesoft-inc.github.io/github-statistics/ https://nebula-graph.io/posts/github-stats-tool/ Enjoy!

How to Compare Multiple GitHub Projects with Our GitHub Stats tool

Graph Therapy. The Year of the Graph Newsletter, June / May 2020 Parts of the world are still in lockdown, while others are returning to some semblance of normalcy. Either way, while the last few months have given some things pause, they have boosted others. It seems like developments in the world of Graph are among those that have been boosted. An abundance of educational material on all things graph has been prepared and delivered online, and is now freely accessible, with more on the way. Graph databases have been making progress and announcements, repositioning themselves by a combination of releasing new features, securing additional funds, and entering strategic partnerships. A key graph database technology, RDF*, which enables compatibility between RDF and property graph databases, is gaining momentum and tool support. And more cutting edge research combining graph AI and knowledge graphs is seeing the light, too. Buckle up and enjoy some graph therapy. Stanford’s series of online seminars featured some of the world’s leading experts on all things graph. If you missed it, or if you’d like to have an overview of what was said, you can find summaries for each lecture in this series of posts by Bob Kasenchak and Ahren Lehnert. Videos from the lectures are available here. Stanford Knowledge Graph Course Not-Quite-Live-Blog Stanford University’s computer science department is offering a free class on Knowledge Graphs available to the public. Stanford is also making recordings of the class available via the class website. Another opportunity to get up to speed with educational material: The entire program of the course “Information Service Engineering” at KIT – Karlsruhe Institute of Technology, is delivered online and made freely available on YouTube. It includes topics such as ontology design, knowledge graph programming, basic graph theory, and more. Information Service Engineering at KIT Knowledge representation as a prerequisite for knowledge graphs. Learn about knowledge representation, ontologies, RDF(S), OWL, SPARQL, etc. Ontology may sound like a formal term, while knowledge graph is a more approachable one. But the 2 are related, and so is ontology and AI. Without a consistent, thoughtful approach to developing, applying, evolving an ontology, AI systems lack underpinning that would allow them to be smart enough to make an impact. The ontology is an investment that will continue to pay off, argue Seth Earley and Josh Bernoff in Harvard Business Review, making the case for how businesses may benefit from a knowldge-centric approach Is Your Data Infrastructure Ready for AI? Even after multiple generations of investments and billions of dollars of digital transformations, organizations struggle to use data to improve customer service, reduce costs, and speed the core processes that provide competitive advantage. AI was supposed to help with that. Besides AI, knowledge graphs have a part to play in the Cloud, too. State is good, and lack of support for Stateful Cloud-native applications is a roadblock for many enterprise use-cases, writes Dave Duggal. Graph knowledge bases are an old idea now being revisited to model complex, distributed domains. Combining high-level abstraction with Cloud-native design principles offers efficient “Context-as-a-Service” for hydrating stateless services. Graph knowledge-based systems can enable composition of Cloud-native services into event-driven dataflow processes. Kubernetes also touches upon Organizational Knowledge, and that may be modeled as a Knowledge Graph. Graph Knowledge Base for Stateful Cloud-Native Applications Extending graph knowledge bases to model distributed systems creates a new kind of information system, one intentionally designed for today’s IT challenges. The Enterprise Knowledge Graph Foundation was recently established to define best practices and mature the marketplace for EKG adoption, with a launch webinar on June the 23rd.. The Foundation defines its mission as including adopting semantic standards, developing best practices for accelerated EKG deployment, curating a repository of reusable models and resources, building a mechanism for engagement and shared knowledge, and advancing the business cases for EKG adoption. Enterprise Knowledge Graph Maturity Model The Enterprise Knowledge Graph Maturity Model (EKG/MM) is the industry-standard definition of the capabilities required for an enterprise knowledge graph. It establishes standard criteria for measuring progress and sets out the practical questions that all involved stakeholders ask to ensure trust, confidence and usage flexibility of data. Each capability area provides a business summary denoting its importance, a definition of the added value from semantic standards and scoring criteria based on five levels of defined maturity. Enterprise Knowledge Graphs is what the Semantic Web Company (SWC) and Ontotext have been about for a long time, too. Two of the vendors in this space that have been around for the longer time just announced a strategic partnership: Ontotext, a graph database and platform provider, meets SWC, a management and added value layer that sits on top. SWC and Ontotext CEOs emphasize how their portfolios are complementary, while the press release states that the companies have implemented a seamless integration of the PoolParty Semantic Suite™ v.8 with the GraphDB™ and Ontotext Platform, which offers benefits for many use cases. Semantic Web Company and Ontotext Partner to Advance Enterprise Knowledge Graphs Ontotext and Semantic Web Company (SWC) — two of the strongest voices advocating the value of knowledge graphs for organizations dealing with large amounts of diverse data — have announced a strategic partnership. Stardog is another graph database and platform provider. Stardog announced it has expanded it completed a Series B round of $11.4 million venture capital funding to mature its go-to-market initiatives. Its CEO set the goals of expanding EU operations, strengthening work in public sector, and developing tools and partnerships. Stardog, the leading Enterprise Knowledge Graph platform, expands Series B to $11.4 million to mature go-to-market initiatives Stardog, the leading Enterprise Knowledge Graph platform, today announced it has expanded its Series B round to $11.4m, securing an additional $3 million from new investors. NebulaGraph is an open source graph database developed by VESoft, a Chinese enterprise. VESoft is ready for further growth after closing an $8 million funding round led by Redpoint China Ventures, an investment firm launched by Silicon Valley-based Redpoint Ventures in 2005 NebulaGraph lists some 20 enterprise clients as users from domains such as social media, ecommerce, and finance. These include the likes of Meituan, Xiaohongshu, and JD.com. NebulaGraph has also been releasing new features, such as the Nebula Studio graph data visualization tool. VESoft raises $8M to meet China’s growing need for graph databases Sherman Ye founded VESoft in 2018 when he saw a growing demand for graph databases in China. VESoft is ready for further growth after closing an $8 million funding round. Microsoft Azure CosmosDB is a globaly distributed, cloud based, multi-model database which also supports graph. New autoscale and serverless features have been announced, to allow better alignment of billing to active usage. Furthermore, a new change feed, and a new Java API. Microsoft is grooming Cosmos DB as its developer-friendly NoSQL database that accommodates massive global web-scale applications but can also be cost-effective for much smaller ones. Microsoft Build brings announcements for cloud data, analytics services, and intersection of the two A series of announcements around Synapse Analytics, Cosmos DB, Azure Database and SQL Edge make this year’s Microsoft Build conference a virtual event revealing actual advances and concrete integrations. As we have often highlighted, a key differentiation among graph databases is their data model. Some are based on RDF, while others on property graphs (even though hybrids exist, too). RDF graph databases are also known as triple stores. Here Alan Morrison answers the question “What are the main pros of property graph databases compared to triplestores?”, quoting Marko Rodriguez, one of the most knowledgeable people in this space. What are the main pros of property graph databases compared to triplestores? How do property graph databases compare to RDF triplestores? RDF is best as a means of strategic integration, property graphs are best for tactical analytics. Neo4j is among the most popular graph databases. Even though it leverages property graphs, it also has an open source plugin called Neosemantics which enables it to work with RDF. A new version of Neosemantics has been released, supporting Persisted Graph Configurations, Model Validations with SHACL, and SKOS import. Some key features of Neosemantics are storing RDF data in Neo4j in a lossless manner (imported RDF can subsequently be exported without losing a single triple in the process), and on-demand exporting property graph data from Neo4j as RDF. Neosemantics 4.0 is out! Neosemantics is a Neo4j plugin that enables the use of the Resource Description Framework (RDF) W3C standard model for data interchange in Neo4j. RDF* is an extenstion to RDF that enables way of mapping RDF and property graphs. RDF* and SPARQL*, the extension to the RDF SPARQL query language, are undergoing standardization via the W3C. Olaf Hartig, RDF* creator, has put together a collection of command line tools and Java libraries to process RDF* data and SPARQL* queries. and , both popular open source tools for working with RDF, have added support for RDF*. RDF graph databases Cambridge Semantics AnzoGraph, Ontotext GraphDB and Stardog now support RDF* and SPARQL*. And Yago, a well-known open knowledge graph uses RDF* to represent statement-level annotations. RDF4J Jena YAGO 4 YAGO 4 is the latest version of the YAGO knowledge base. It is based on Wikidata — the largest public general-purpose knowledge base. The good news for RDF and SPARQL do not end here. Now data science notebook users can query public knowledge graph SPARQL endpoints directly, via integration with Jupyter and Zeppelin Notebooks, as Bob DuCharme shows. In addition, , which lets users visually browse the endpoints. Zazuko has released an open source SPARQL endpoint explorer SPARQL in a Jupyter Notebook Paulo Villegas has released a SPARQL kernel for Jupyter notebooks that lets us run queries natively, and I have been having some fun with it. More AI and data science overlap with the graph world: StellarGraph, an open source library for machine learning on graphs & networks, has released version 1.0. It includes algorithms and examples for Node classification, Link prediction, Unsupervised training / representation learning, and Graph classification. StellarGraph 1.0 — taking graph machine learning to a new level Today we delivered version 1.0 of the open-source, user-friendly StellarGraph library for machine learning (ML) on graphs and networks. It’s the culmination of three years of active research and engineering. Jure Leskovac, one of the key researchers in Graph AI, has recently presented advancements in Deep Learning for Graphs at the Deep Learning for Graphs workshop at The Web Conference. This includes a new version of the , a collection of realistic, large-scale, diverse benchmark datasets for machine learning with graphs. Open Graph Benchmark Advancements in Deep Learning for Graphs Position-aware Graph Neural Networks, Strategies for Pretraining GNNs and the Open Graph Benchmark. More cutting edge graph + AI research: SeMi, the SEmantic Modeling machIne, is a tool to semi-automatically build large-scale Knowledge Graphs from structured sources: CSV, JSON, or XML. It builds semantic models of data sources with concepts and relations in a domain ontology, and uses a graph neural network SeMi: A SEmantic Modeling machIne to build Knowledge Graphs with graph neural networks SeMi (SEmantic Modeling machIne) is a tool to semi-automatically build large-scale Knowledge Graphs from structured sources such as CSV, JSON, and XML files. Wrapping up with some COVID-19 related initiatives. The NSF has awarded funding for a Semantic Integration Platform to Combat COVID-19. COVID-19 Net will refine a knowledge graph and integrate it with complementary knowledge graphs. The Italian government publishes daily official COVID-19 open data. Now the , using the RDF Data Cube Vocabulary. data is available as linked data A that enables users to compare news from the BBC, CNN, Fox and DW News has been created by Loomi Assistant COVID-19 Knowledge Graph Web Tool NSF Awards Funding for Semantic Integration Platform to Combat COVID-19 The NSF has awarded two researchers at the San Diego Supercomputer Center (SDSC) funding to organize COVID-19 information into a transdisciplinary knowledge network that integrates health, pathogen, and environmental data to better track cases to improve analysis and forecasting across the greater San Diego region. To subscribe the to the Year of the Graph Newsletter, click here Previously published at https://yearofthegraph.xyz/newsletter/2020/06/graph-therapy-the-year-of-the-graph-newsletter-june-may-2020/

Buckle Up and Enjoy Some Graph Therapy

Hello, in the first article of this series, I will examine the KNIME data science software. I will also explain how to install the KNIME application, which is written in Java and built on Eclipse. This application can prepare data science and artificial intelligence applications with workflow-style visual programming, and it can be configured on widely used GNU/Linux systems.  I will review its usage with a machine learning application and save the application I prepared in a Github repo. KNIME KNIME Analytics is a data science environment written in Java. This software allows visual programming in the form of a workflow using various nodes and is an application that allows to development of a data mining application even without knowing advanced coding. It has a very diverse and rich plugin center and is used quite often in academia as well. It is an extensible data science platform where user-created scripts and codes can be used as well as visual programming. KNIME is a cross-platform software that supports installation on many operating systems. You can click the to download. In this article, I will review KNIME for GNU/Linux distributions only. link Configuration You can extract the archive of the KNIME application to the desired location. tar.gz ~$ tar xvf knime-analytic-?.?.?.tar.gz -C /opt/knime All libraries and plugins for KNIME are available in the directory. There is a binary file named and you can start the application using it. But it needs to work. Knime java JAVA 11 KNIME Analytics works with Java 11 and higher. For this reason, you can install either or packages for KNIME. Depending on the distribution you use, you can easily download and install these JDKs from the main repository. openjdk-11 openjdk-latest For example, for RHEL based ones; ~$ sudo dnf/yum install java-11-openjdk # or java-latest-openjdk Or Debian based ones; ~$ sudo apt install openjdk-11-jdk # or default-jre Another option I can suggest here is the liberica JDK versions published by Belsoft. These are open-source and freely distributed Java JDK versions. You can download and install JDK with many options such as standard and full package. You can find installation scripts or archives [on this page] ( ) for many operating systems. For KNIME Analytics, standard JDK-11-lts is sufficient. For Linux, we need to download the tar.gz package and extract it to a directory. Then the and variables are updated and the Java installation is completed. https://bell-sw.com/pages/downloads/#mn JAVA_HOME PATH ~$ mkdir -p ~/libertica-jdks
~$ tar xvf /path/to/downloaded-jdk.tar.gz -C ~/libertica-jdks/

~$ export JAVA_HOME=~/libertica-jdks/jdk-11.?.?
~$ export PATH=$PATH:JAVA_HOME/bin
## after this
~$ java -version JDK is available in this session. If you want to use it in this location all the time, you should add the lines exported for JAVA_HOME and PATH to your or file if you are using zsh. .bashrc .zshrc After the Java installation, it is sufficient to go to the directory where KNIME is installed and run the script. If you have more than one JDK installed on your system, you can specifically give the path to JDK-11 with . ./knime ./knime -v /path/to/jdk-11/bin If you want to create a for this; dektop entry [Desktop Entry]
Type=Application
Name=KNIME Analytic Platform
Description=Data Science Environment
Exec=/path/to/knime-folder/knime_4.?.?/knime
Icon=/rpath/to/knime-folder/knime_4.?.?/icon.svg
Categories=Development;Science;
terminal=false You can create a file named and save the entry to the relevant location. If you have a problem with the exec command. You can give a shell script that runs the ./knime script as a parameter in the command. If you are using Wayland as a display server, you may have problems with the application. For this reason, you can add the line to your configuration file or or whatever shell you are using, or inside your script file that starts KNIME. If you're already using x11, you won't have any problems. For example, the shell script that starts KNIME; ~/.local/share/application/knime.desktop exec export GDK_BACKEND=x11 bashrc zshrc #/bin/bash
export GDK_BACKEND=x11
./knime -v /path/to/java-jdk-11/bin may form. Extension Installations The KNIME application had many extensions. The high number of users and its extensibility are the most important factors that bring it to the top, among other data mining applications. You can open the interface by selecting from the menu in the application. You can install it by searching for the add-on you want. For example, you can install the plugin that should be used to connect to the Twitter API and pull data. It will be installed with the necessary dependency packages. The application will need to be restarted before it can read new plugins. Install KNIME Extensions... File KNIME twitter connector Then you can search for the node you want from the section and add it to your project. Node Repository Machine Learning Application with KNIME In this section, a ready-made dataset will be used to prepare a machine learning application. A data mining workflow will be created with KNME nodes by using the dataset named in the . The project is created with from the menu. HCV Data Dataset UCI Machine Learning Repository new project File Node Repository I add my file to the project by searching or from the section. Similarly, I search for the transactions I want to do and add them to my project and run them, and at the end of each operation, I give the output as the input of the next node. file reader csv reader Node Repository When I right-click on the nodes, I configure the operation and then run it. When I right-click again, I can see the output of the node as a result of the operation under the menu. The node below outputs the normalized table and model. Normalize The operations performed in this application can be seen as follows. The operations performed in this application can be seen as follows. In the application, the data in the CSV file was first read with the node and the categorical values ​​such as were given to the node to be converted into numbers. The output of this node is given to the node to extract the Id and categorical gender values. The output dataset is given to the node. The dataset with 0-1 normalization was given to the node to be divided into 70% training and 30% testing. A model was created by giving the training dataset from the parts to the node. This model and test dataset was tested by giving it to the node. And the output of the node has been transformed into a table with the comparison matrix and score values ​​related to the performance in the node. csv reader sex category to number column filter Normalize Partitioning RProp MLP Learner MultiLayerPerceptron Predicter Scorer When our perceptron model was tested with 1 hidden layer and 10 neurons, it was seen that our comparison matrix and performance values, respectively; It seems to be a very successful model, here the dataset was not raw data. The performance of the data preprocessing on the data set was 98% accurate. Preprocessing is an important factor for model performance. If you create a model with the raw data set, you can see that you cannot achieve high success. Due to the preprocessing of this dataset; Reviewed with R Sample dataset review with Smote Outlier cleaning with R boxplot Second-time dataset with SMOTE balancing You can find this project and its dataset in the repo in the link. Resources and Project Github repo HCV Data Dataset Originally published . here

Stories, News & Mentions about VELSOFT

Velsoft’s Stories on HackerNoon

Velsoft's News & Mentions