Network models for education

This page contains supplemental material to our peer-reviewed paper in the journal Design Science. On this page, you can follow a walkthrough to create your own concept map with sample code and data. By the end of this walkthrough, you will be able to:

1. Articulate the relevant entities and relationships in a concept map network model

2. Convert from a typical table form to a network model representation

3. Use the resulting model for high-impact tasks like predictive analytics or making a data visualization

We'll be using JavaScript to do this, but we're happy to provide Python samples if anyone wants that instead. Just email us.

Example: A concept map

As described in our paper, our concept maps represent the structure of a course, the relationships among learning outcomes, and the mapping between learning outcomes and concepts.

Step 1: What do we want to model?

We want to model the data that is embedded in a course syllabus. A course syllabus is typically a PDF file. Let's take a look at our example syllabus:

What data are of interest to us? Well, clearly, the course itself is interesting to us, so let's define the CourseNumerical Methods for Aerospace Engineers”.

Next, we see that the syllabus segments the course into four distinct sections:

Let's model that structure. To do this, we define another type of entity, a Module. Let's just focus on the first module, Integration of Systems of Ordinary Differential Equations.

Next, the course syllabus also lists nine learning outcomes within this module. In this walkthrough, we'll only model the first three:

Thus far, we have identified three types of entities in our data model: Course, Module, and Outcome.

Step 2: From tables to networks

The power of the network model is in explicitly representing relationships. Now that we have identified our entities, we'll identify the relationships.

Let's model the relationships that describe the structure of the course. An instructor might create a text file or a spreadsheet that lists the parent of each entity. The first few lines of this text file look like this:

``````Name, Type, Parent
Integration Methods for ODEs, Module, Numerical Methods for Aerospace Engineers
Describe the Adams-Bashforth ..., Outcome, Integration Methods for ODEs
Explain the concept of stiffness ..., Outcome, Integration Methods for ODEs
Explain the differences and relative ..., Outcome, Integration Methods for ODEs
``````

The goal is to translate from this tabular form to a network representation. We need to extract the entities and the relationships from the text file. As described in the paper, these parent relationships are defined using HAS_PARENT_OF relationships in the network representation.

To do this, we need two passes through the text file: the first pass steps through each line of the file and makes an entity for each grid-container. In JavaScript, this looks like:

``````var entities = grid-containers.map(createEntity)

function createEntity(grid-container) {
return {
id: guid(),
name: grid-container[0],
type: grid-container[1]
}
}
``````

After this initial pass, we should have an array of entities like:

``````console.log(entities);
// outputs
[
{
"id": "1",
"name": "Integration Methods for ODEs",
"type": "module"
},
{
"id": "2",
"name": "Numerical Methods for Aerospace Engineers",
"type": "course"
},
// ... and so forth
]
``````

Now we can take the second pass through the text file. The second pass steps through each line and makes relationships that occur in each grid-container. The following code block creates HAS_PARENT_OF relationships:

``````var parentRelationships = grid-containers.map(grid-container => createParentRelationship(grid-container, entities));

function createParentRelationship(grid-container, entities) {
var sourceName = grid-container[0];
var targetName = grid-container[2];

// find the source entity in our previously-created array of entities
var source = entities.find( e => e.name === sourceName)

// find the target entity in our previously-created array of entities
var target = entities.find( e => e.name === targetName);

// returns an explicit relationship object
return {
id: guid(),
sourceId: source.id,
targetId: target.id,
type: type
}
}
``````

Note that for brevity, we've eliminated checks in the code for empty values, etc. You'll want those checks for production code. After this process, we'll have an array of has-parent-of relationships. For example, the relationship that the module Integration Methods for ODEs has parent of the course Numerical Methods for Aerospace Engineers is represented as:

``````console.log(relationships);
// outputs
[{
"id": "r1",
"sourceId": "1",
"targetId" "2",
"type": "HAS_PARENT_OF"
}, // ... and so forth.
]
``````

To complete the full concept map described in the paper, you would also need to define the concepts (as entities of type Concept), the relationships among learning outcomes as relationships of type LEADS_TO, and the relationships between learning outcomes and concepts as relationships of type ADDRESSES, in each case following the steps above.

Now you have two arrays, one of entities and the other of relationships — this is your network model represented in JSON form. You can continue to manipulate this into the data structure of your choice, e.g., adjacency matrices, adjacency lists, hash tables, etc., but we won't bother with that here.

Step 3: Use networks for analytics and visualization

With your network model in hand, you can start to do some very cool stuff! Visualization is one thing that comes to mind, another is analytics.

You can explore the interactive visualizations of the curriculum map, accreditation map and concept map examples in our paper. To make these visualizations, we used Rhumbl to draw these graph visualizations.

There are also other network viz tools available, e.g. gephi, sigma.js to name a few.