About this book

KNIME is an open source data analytics, reporting, and integration platform, which allows you to analyze a small or large amount of data without having to reach out to programming languages like R.

"KNIME Essentials" teaches you all you need to know to start processing your first data sets using KNIME. It covers topics like installation, data processing, and data visualization including the KNIME reporting features. Data processing forms a fundamental part of KNIME, and KNIME Essentials ensures that you are fully comfortable with this aspect of KNIME before showing you how to visualize this data and generate reports.

"KNIME Essentials" guides you through the process of the installation of KNIME through to the generation of reports based on data. The main parts between these two phases are the data processing and the visualization. The KNIME variants of data analysis concepts are introduced, and after the configuration and installation description comes the data processing which has many options to convert or extend it. Visualization makes it easier to get an overview for parts of the data, while reporting offers a way to summarize them in a nice way.

Publication date:
October 2013


Chapter 1. Installing and Using KNIME

In this chapter, we will go through the installation of KNIME, add some useful extensions, customize the settings, and find out how to use it for basic tasks. You will also be familiarized with the terminology of KNIME, so there's no misunderstanding in the later chapters.

As always, it is a good idea to read the manual of the software you get. You will find a short introduction on KNIME in the file, quickstart.pdf, present in the installation folder. The topics we will cover in the chapter are as follows:

  • Installation of KNIME on different platforms

  • Terms used in KNIME

  • Introduction to the KNIME user interface


Few words about KNIME

KNIME is an open source (GNU GPL available at http://www.gnu.org/licenses/gpl.html) data analytics platform with a large set of building blocks and third-party tools. You can use it from loading your data to a final report or to predict new values using a previously found model.

KNIME is available in four flavors: Desktop/Professional, Team Space, Server, and Cluster Execution. Only the Desktop version is open source; with a Professional subscription, you will get support for it, and also support the future development of KNIME. We will cover only the open source version. There is also an SDK version for free, but it is intended for use by node developers. Most probably, you will not need it yet.

At the time of writing this book, KNIME Desktop 2.8.0 was the latest version available; all the information presented in this book is based on that version.


Installing KNIME

KNIME is supported by various operating systems on 32-bit and 64-bit x86 Intel-architecture-based platforms. These operating systems are: Windows (from XP to Windows 8 at the time of writing this book) and Linux (most modern Linux operating systems work well with KNIME, Mac OS X (10.6 and above); you can check the list of supported platforms for details at: http://www.eclipse.org/eclipse/development/readme_eclipse_3.7.1.html. It also supports Java 7 on Windows and Linux, so extensions requiring Java 7 can be used too. Unfortunately under Mac OS X, there were some problems with Java 7. So on Mac OS X, the recommended version is Java 6.

There are two ways to install KNIME: an easier way is to unpack the archive you can download from their site, and a bit more complicated way is to install KNIME to an existing Eclipse installation as a plugin. Both have use cases, but the general recommendation is to install it from an archive.

Installation using the archive

We assume you are using the open source version of KNIME, which can be downloaded from the following address (always download the latest version):


It is not necessary to subscribe to the newsletters, but if you have not done it yet, it might be worth doing it. Some of the newsletters also contain tips for KNIME usage. This is quite infrequent, usually one per month.

The supported operating system versions are 32-bit and 64-bit for Linux and Windows, and 64-bit for Mac OS X.

KNIME for Windows

KNIME is available in an executable file for Windows (in a 7-zip compressed format). You can execute it as a regular user (unless your network administrator blacklists running executable files that are downloaded from the Internet); just double-click on it and in the window that appears, select the destination folder.


On an older version of Windows (7 and older), there is a limitation to the path length; it cannot be longer than 260 characters. KNIME and some extensions can get close to this limit, so it is recommended to install it to a short path. Installing it to Program Files is not recommended.

You do not have to specify the folder name (such as knime), as a folder with the name knime_KNIME version (in our case knime_2.8.0) will be created at the destination address, and it will contain the whole installation. You can have multiple versions installed.

You can start KNIME GUI with the knime.exe executable file from that folder. You can create a shortcut of it on your desktop using the right-click menu by navigating to Send to | Desktop (create shortcut). On its first start, KNIME might ask for permissions to connect to the Internet. This may require administrator rights, but it is usually a good idea to change the firewall settings to let KNIME through.

KNIME for Linux

This file is just a simple tar.gz archive. You can unzip it using a command similar to the one shown as follows:

$ tar –xvzf knime_2.8.0.linux.gtk.x86_64.tar.gz –C /path/to/extract

Alternatively, you can use your favorite archive-handling tool to achieve similar results. The executable you need is named knime. Your window manager's manual might help you create application launchers for this executable if you prefer to have one.

KNIME for Mac OS X

You should drag the dmg file to the Applications place, and if you have Java installed, it should just work. The executable to start is called knime.app from the command line, knime.app/Contents/MacOS/knime.


If you have problems installing KNIME, maybe others also had similar problems; please check the FAQ page of KNIME at http://tech.knime.org/faq first. If it does not solve your problem, you should search the forum at http://tech.knime.org/forum; if even that fails to help, ask the experts there.


KNIME terminologies

It is important to share your thoughts and problems using the same terms. This makes it easier to reach your goal, and others will appreciate if it is easy to understand. This section will introduce the main concepts of KNIME.

Organizing your work

In KNIME, you store your files in a workspace. When KNIME starts, you can specify which workspace you want to use. The workspaces are not just for files; they also contain settings and logs. It might be a good idea to set up an empty workspace, and instead of customizing a new one each time, you start a new project; you just copy (extract) it to the place you want to use, and open it with KNIME (or switch to it).

The workspace can contain workflow groups (sometimes referred to as workflow set) or workflows. The groups are like folders in a filesystem that can help organize your workflows. Workflows might be your programs and processes that describe the steps which should be applied to load, analyze, visualize, or transform the data you have, something like an execution plan. Workflows contain the executable parts, which can be edited using the workflow editor, which in turn is similar to a canvas. Both the groups and the workflows might have metadata associated with them, such as the creation date, author, or comments (even the workspace can contain such information).

Workflows might contain nodes, meta nodes, connections, workflow variables (or just flow variables), workflow credentials, and annotations besides the previously introduced metadata.

Workflow credentials is the place where you can store your login name and password for different connections. These are kept safe, but you can access them easily.


It is safe to share a workflow if you use only the workflow credentials for sensitive information (although the user name will be saved).


Each node has a type, which identifies the algorithm associated with the node. You can think of the type as a template; it specifies how to execute for different inputs and parameters, and what should be the result. The nodes are similar to functions (or operators) in programs.

The node types are organized according to the following general types, which specify the color and the shape of the node for easier understanding of workflows. The general types are shown in the following image:

Example representation of different general types of nodes

The nodes are organized in categories; this way, it is easier to find them.

Each node has a node documentation that describes what can be achieved using that type of node, possibly use cases or tips. It also contains information about parameters and possible input ports and output ports. (Sometimes the last two are called inports and outports, or even in-ports and out-ports.)

Parameters are usually single values (for example, filename, column name, text, number, date, and so on) associated with an identifier; although, having an array of texts is also possible. These are the settings that influence the execution of a node. There are other things that can modify the results, such as workflow variables or any other state observable from KNIME.

Node lifecycle

Nodes can have any of the following states:

  • Misconfigured (also called IDLE)

  • Configured

  • Queued for execution

  • Running

  • Executed

There are possible warnings in most of the states, which might be important; you can read them by moving the mouse pointer over the triangle sign.

Meta nodes

Meta nodes look like normal nodes at first sight, although they contain other nodes (or meta nodes) inside them. The associated context of the node might give options for special execution. Usually they help to keep your workflow organized and less scary at first sight.

A user-defined meta node


The ports are where data in some form flows through from one node to another. The most common port type is the data table. These are represented by white triangles. The input ports (where data is expected to get into) are on the left-hand side of the nodes, but the output ports (where the created data comes out) are on the right-hand side of the nodes. You cannot mix and match the different kinds of ports. It is also not allowed to connect a node's output to its input or create circles in the graph of nodes; you have to create a loop if you want to achieve something similar to that.


Currently, all ports in the standard KNIME distribution are presenting the results only when they are ready; although the infrastructure already allows other strategies, such as streaming, where you can view partial results too.

The ports might contain information about the data even if their nodes are not yet executed.

Data tables

These are the most common form of port types. It is similar to an Excel sheet or a data table in the database. Sometimes these are named example set or data frame.

Each data table has a name, a structure (or schema, a table specification), and possibly properties. The structure describes the data present in the table by storing some properties about the columns. In other contexts, columns may be called attributes, variables, or features.

A column can only contain data of a single type (but the types form a hierarchy from the top and can be of any type). Each column has a type, a name, and a position within the table. Besides these, they might also contain further information, for example, statistics about the contained values or color/shape information for visual representation. There is always something in the data tables that looks like a column, even if it is not really a column. This is where the identifiers for the rows are held, that is, the row keys.

There can be multiple rows in the table, just like in most of the other data handling software (similar to observations or records). The row keys are unique (textual) identifiers within the table. They have multiple roles besides that; for example, usually row keys are the labels when showing the data, so always try to find user-friendly identifiers for the rows.

At the intersection of rows and columns are the (data) cells, similar to the data found in Excel sheets or in database tables (whereas in other contexts, it might refer to the data similar to values or fields). There is a special cell that represents the missing values.


The missing value is usually represented as a question mark (?).


If you have to represent more information about the missing data, you should consider adding a new column for each column, where this requirement is present, and add that information; however, in the original column, you just declare it as missing.

There are multiple cell types in KNIME, and the following table contains the most important ones:

Cell type



Int cell


This represents integral numbers in the range from -231 to 231-1 (approximately 2E9).

Long cell


This represents larger integral numbers, and their range is from -263 to 263-1 (approximately 9E18).

Double cell


This represents real numbers with double (64 bit) floating point precision.

String cell


This represents unstructured textual information.

Date and time cell

calendar & clock

With these cells, you can store either date or time.

Boolean cell


This represents logical values from the Boolean algebra (true or false); note that you cannot exclude the missing value.

Xml cell


This cell is ideal for structured data.

Set cell


This cell can contain multiple cells (so a collection cell type) of the same type (no duplication or order of values are preserved).

List cell


This is also a collection cell type, but this keeps the order and does not filter out the duplicates.

Unknown type cell


When you have different type of cells in a column (or in a collection cell), this is the generic cell type used.

There are other cell types, for example, the ones for chemical data structures (SMILES, CDK, and so on), for images (SVG cell, PNG cell, and so on), or for documents. This is extensible, so the other extension can define custom data cell types.


Note that any data cell type can contain the missing value.

Port view

The port view allows you to get information about the content of the port. Complete content is available only after the node is executed, but usually some information is available even before that. This is very handy when you are constructing the workflow. You can check the structure of the data even if you will usually use node view in the later stages of data exploration during workflow construction.

Flow variables

Workflows can contain flow variables, which can act as a loop counter, a column name, or even an expression for a node parameter. These are not constants, but you can introduce them to the workspace level as well.

This is a powerful feature; once you master it, you can create workflows you thought were impossible to create using KNIME. A typical use case for them is to assign roles to different columns (by assigning the column names to the role name as a flow variable) and use this information for node configurations. If your workflow has some important parameters that should be adjusted or set before each execution (for example a file name), this is an ideal option to provide these to the user; use the flow variables instead of a preset value that is hard to find. As the automatic generation of figures gets more support, the flow variables will find use there too.

Iterating a range of values or files in a folder should also be done using flow variables.

Node views

Nodes can also have node views associated with them. These help to visualize your data or a model, show the node's internal state, or select a subset of the data using the HiLite feature. An important feature exists that a node's views can be opened multiple times. This allows us to compare different options of visualization without taking screenshots or having to remember what was it like, and how you reached that state. You can export these views to image files.


The HiLite feature of KNIME is quite unique. Its purpose is to help identify a group of data that is important or interesting for some reason. This is related to the node views, as this selection is only visible in nodes with node views (for example, it is not available in port views). Support for data high lighting is optional, because not all views support this feature.

The HiLite selection data is based on row keys, and this information can be lost when the row keys change. For this reason, some of the nonview nodes also have an option to keep this information propagated to the adjacent nodes. On the other hand, when the row keys remain the same, the marks in different views point to the same data rows.

It is very important that the HiLite selection is only visible in a well-connected subgraph of workflow. It can also be available for non-executed nodes (for example, the HiLite Collector node).


The HiLite information is not saved in the workflow, so you should use the HiLite filter node once you are satisfied with your selection to save that state, and you can reset that HiLite later.

Eclipse concepts

Because KNIME is based on the Eclipse platform (http://eclipse.org), it inherits some of its features too. One of them is the workspace model with projects (workflows in case of KNIME), and another important one is modularity. You can extend KNIME's functionality using plugins and features; sometimes these are named KNIME extensions. The extensions are distributed through update sites, which allow you to install updates or install new software from a local folder, a zip file, or an Internet location.

The help system, the update mechanism (with proxy settings), or the file search feature are also provided by Eclipse. Eclipse's main window is the workbench. The most typical features are the perspectives and the views. Perspectives are about how the parts of the UI are arranged, while these independently configurable parts are the views. These views have nothing to do with node views or port views. The Eclipse/KNIME views can be detached, closed, moved around, minimized, or maximized within the window. Usually each view can have at most one instance visible (the Console view is an exception). KNIME does not support alternative perspectives (arrangements of views), so it is not important for you; however, you can still reset it to its original state.

It might be important to know that Eclipse keeps the contents of files and folders in a special form. If you generate files, you should refresh the content to load it from the filesystem. You can do this from the context menu, but it can also be automated if you prefer that option.


The preferences are associated with the workspace you use. This is where most of the Eclipse and KNIME settings are to be specified. The node parameters are stored in the workflows (which are also within the workspace), and these parameters are not considered to be preferences.


KNIME has something to tell you about almost every action. Usually, you do not care to read these logs, you do not need to do so. For this reason, KNIME dispatches these messages using different channels. There is a file in the workplace that collects all the messages by default with considerable details. There is even a KNIME/Eclipse view named Console, which contains only the most important details initially.


User interface

So far, you got familiar with the concepts of KNIME and also installed it. Let's run it!

Getting started

When you start the program, the first dialog asks for the location of the workspace you want to use. If the location does not exist, it will be created.

After this, a splash screen will inform you about the progress of the start, and bring you to the welcome screen.

In the background, your firewall might notify you that this program wants to connect to other computers. This is normal; it loads tips from the Internet and tests whether other services (for example, the public repository of KNIME workflows) are available or not. You can allow this if you have permission to do so, but unless you want to connect to other servers, you do not have to give that permission.

The welcome screen shows two main options: one for initializing the workbench for first use, and the other is to install new extensions.

Before we select either of them, we will introduce the most important preferences, because configuring before the first use is always useful.

Setting preferences

Navigate to the Preferences... menu item under File | Preferences... to gain access to the preferences dialog. In the General section, you will see an option to enable Show heap status. It is useful, because it can help you optimize the memory settings for KNIME. I suggest you to turn it on. It will be visible in the lower-right corner of the status bar.


You can set some KNIME-related options in the preferences of the KNIME category.

The KNIME GUI subcategory contains confirmation, Console logging, workflow editor grid options, and some text-related options.

If you want to connect to databases, you should find a driver for your database, and register it by navigating to KNIME | Database Driver. There, you can add the archive file, and later, you will be able to use them in database connections.


Database drivers

You can find JDBC database drivers on your database provider's homepage, but you can also try the JDBC database: http://www.databasedrivers.com/jdbc/

With Preferred Renderers you can set the default renderers for the columns. This options is especially useful if you are working with chemical structures.

The main KNIME preference page contains the file logging detail settings, the parallelism option, and the path to the temporary files.

Other preferences

To set up the proxy, you should navigate to General | Network Connections.

In the General | Keys page, you can redefine the key bindings for KNIME commands. So, you can use the shortcuts with which you are familiar or comfortable on your keyboard.

General | Web Browser and the Help pages are especially useful when you have problems displaying help, or you want to browse local help in your browser.

You can also set some update sites by navigating to Install/Update | Available Software Sites, but usually that is also done by navigating to Help | Install New Software....

You can uninstall extensions by navigating to Help | About KNIME behind the Installation Details button's dialog. The Installed Software tab contains the extensions; you can uninstall them with a button.

Installing extensions

For installing extensions you need some update sites. You already have the default KNIME options, which contain some useful extensions. There are community nodes that also add helpful functionality to KNIME. The stable update site is http://tech.knime.org/update/community-contributions/2.8, while nightly builds are available at http://tech.knime.org/update/community-contributions/nightly.

To add update sites, navigate to Help | Install New Software.... Once you have selected an update site, it will download its summary so you can select which extensions (features) you want to install. These features have short descriptions, so you can have an idea what functionality it will offer after installation. Once you have selected what you want to install from the update site, you should click Next.

The wizard's next page gives some details and summaries about the selected features.

On the next page, you can check the licenses and accept them if you are OK with them. After clicking Finish, the installation starts. During the installation, you might be asked to check whether you really want to install extensions with unsigned content, or you want to accept a signing key. Once it is ready, you will be asked to restart your workbench. After restarting it, you can use the features that were installed; however, sometimes there are some preferences to be set before using them.


So far, we have set up the work environment and installed some extensions. Now let's select the large button named Open KNIME Workbench.

The initial workbench

The menu bar is similar to any other menu bar, just like the toolbars and the status bar. We will cover the menu bar and the toolbar in detail.

The KNIME Explorer view can be used to handle your workflows, workflow groups, or connect to KNIME servers. The Favorite Nodes view contains the favorite, last used, and most used nodes as a shortcut. You can specify the maximum number of items that should be there.


You should play with the view controls a bit more and get familiar with their usage.

Node Repository is one of the most important views. It contains nodes organized in categories. The search box is really helpful when it comes to the workflow design, and if you remember a part of the name but not its category. You will use this feature quite often.

The Outline view gives an overview on what is in the current editor window; it can also help navigating if the window is too large.


It is considered bad practice to have a single, huge workflow for your task. Using meta nodes, you can have more compact parts in every level.

The Console view contains messages—initially only the important ones.

The Node Description tab provides you with help information for the selected node. Information on how you should use it, what are the parameters, what should be its input, what is its output, and what kind of views are available are answered in that tab. When you select a category in the Node Repository view, the contents of the category will be displayed.

And finally, the central area of the window is for the workflow editor. A workflow named KNIME_project was created. Now, you can start working on it. Try adding the File Reader node from the IO | Read category in Node Repository. Drag it from the repository to the workflow or just double-click it in the repository, move it around, add another, delete it using the context menu, and that would be a good start.

The Undo (Ctrl + Z) and Redo (Ctrl + Y) commands from the Edit or the context menu (or from the toolbar: curved left and right arrows) can help you go back to the previous editing state.

Workflow handling

To create a workflow group, open the context menu of the LOCAL (Local Workspace) item in the KNIME Explorer view and select New Workflow Group... from the menu. Specify the name of the workflow group and where it should be created (once you have more groups, you can create groups inside those too). Creating a workflow can also be done using the New Workflow... command. These commands are also available from the File | New... (Ctrl + N) dialog.


The key bindings are not always easy to remember because there are many of them; for more information and help about them, navigate to the Help | Key Assist... menu item or use Ctrl + Shift + L.

To load a workflow, first you have to make it available locally. There are many options to do that. You can import it to the workspace using the File | Import KNIME workflow... dialog (also available from the context menu).


There is a file named ExampleFlow.zip in the installation folder; you can use that.


The Example Flow workflow loads the iris dataset (do not reset that node), colors the rows according to their class label, and visualizes the data in three different ways.

Another option is to download a workflow from the KNIME Server. Fortunately, the public KNIME Server is available for guests too. First you have to log in using the context menu. Select the only available option, Login. Once the catalog has been loaded, you can browse it similar to what you can do with the local workspace. But you cannot open the workflow from there. You have to select the one you want to import and copy it (in the context menu, use Copy or press Ctrl + C). Once you have the right place in the local workspace, insert the workflow (in the context menu use Paste, or press Ctrl + V).

The metadata information can be handy if you want to know when it was created, who the author is, or what did someone comment. The comment information is especially handy if you want to choose the workflow you want to download. To get (or set for local workflows) this information, the context menu's Show Meta Information (or Edit Meta Information...) command should be used.


Describe your dependencies

If you mention the prerequisites to your workflow, it will help the next user (who may be the future you) to set up things properly.

In loaded workflows, sometimes there are yellow notes about the structure of the workflow to grab your attention for customization options, and others. You can create your own notes from the context menu of the workflow editor using the New Workflow Annotation menu item. You can close the workflow by closing its editor.

The context menu gives options to Rename... (F2) (only available for closed workflows), Delete... (Delete), Copy (Ctrl + C), Paste (Ctrl + V), or Cut (Ctrl + X)—or just move using dragging—workflows or workflow groups.

The quickstart.pdf file describes how you can export workflows to share them with other users. The web guide for this is available at: http://tech.knime.org/workbench#export

Node controls

Once you have nodes in the editor, you want to configure it. To do that, you should double-click it, select it from the context menu or the Node menu using the Configure... command, or use the toolbar's checklist icon (also accessible by pressing F6). This opens a configuration dialog (Line Reader node), as shown in the following screenshot:

Example configuration dialog

This way you can set the parameters of the node. There can be various controls, usually with helpful tooltips; you can open them in a side window, and add the node description too. You might wonder what should that v=? button do. It opens up the variable settings. For example, you can use the filename in subsequent nodes as a flow variable, or substitute it with a flow variable, if that is what you need.

The configurations are organized in tabs. The last two tabs are present in all the configuration dialogs. The Flow Variables tab allows you to assign flow variables to the parameters as values, as shown in the following screenshot:

The Flow Variables tab

The Memory Policy tab is seldom needed; you can specify how the data should be handled within KNIME during execution of the node, as shown in the following screenshot:

The Memory Policy tab

It really helps to identify the nodes or their purpose if you give them meaningful names. To change the name, click on a previously selected node or press F2. If you want more detailed information, you might consider adding a workflow annotation around it. Alternatively, you might want to add a node description to it by navigating to the context menu item Edit Node Description..., or the Node menu Edit Node Name and Description... (Alt + F2), or by clicking the toolbar's yellow speech balloon. This information will be the tooltip of the node.

If you find the names distracting or if they are the default name, you can hide or enable them by navigating to Node | Hide Node Names, by pressing Ctrl + Alt + Q or the stroked through text on the toolbar.

The way from not configured to configured, and then the executing and executed states.

We want to execute the node to get the results. To achieve this, select the context menu or the Node menu, and select Execute (F7). On the toolbar, this is the play button (a white triangle on green circle). You can also schedule execution to show the first view after that (Shift + F10). You can change your mind and try to stop the execution before it is finished. For this purpose, navigate to Node | Cancel Execution (F9) of the selected nodes, or navigate to Node | Cancel All Execution (Shift + F9).

There might be warnings or errors even after the execution; you will be notified about those.

If the execution finishes successfully, you can check the ports by selecting one of them from the context menu; alternatively, if you want to check the first output port, navigate to Node | Open First Out-Port View (Shift + F6, a magnifier over a table on the toolbar). Checking views is a good idea too (it can be selected from the context menu or via Node | Open First View, F10, a magnifier on the toolbar). The node views also have some common parts: the File and the HiLite menus.

If you make changes to the configuration, your node will be reset to the configured state; it can also be achieved using Node or the context menu's Reset (F8) command (or the toolbar's x-table button). The reset will not delete the previously set parameters.

To connect a node's output port to another node's input port, just drag the output port to the input port; when the mouse button is released they will be connected (assuming the ports are compatible and would not create cycle in the graph of nodes). From one output port, you can connect to as many input nodes as you want (to same nodes too), but the input ports can only handle one port at the most.

There are arrangement commands available on the toolbar (horizontal, vertical, and auto layout), and you can also configure the node snapping grid properties by navigating to Node | Grid Settings... (Ctrl + Alt + Shift + X) from the toolbar—a grid.


As we mentioned previously, HiLite is a view-related feature of KNIME, which allows selecting certain set of rows and making it visible across different rows. The Example Flow is a good start to get familiar with this concept and see it in action. As you can see, there are four visual type nodes available, the Color Manager, Scatter Plot, Parallel Coordinates, and Interactive table. Please open a view for the last three nodes, and also execute them in the same order.

The interactive table node shows data with different colors for different flowers. Select the first Iris-versicolor row, 51. Now from the HiLite menu, select HiLite selected (also available from the context menu in this view). As you can see, a point and a path has already been highlighted on the other two views—those representing the row 51. If you try, you can highlight another row from the Interactive table view; you can select some dots from the scatter plot or paths from the parallel coordinates. Highlighting them can be done similar to what you did in the first view. You also have the option to selectively unhighlight (UnHiLite Selected) or unhighlight all (Clear HiLite). You can also hide or keep only the highlighted rows (in the view, the port content will not be changed) using the HiLite | Filter menu items.

To store the HiLite information, you should add HiLite Filter (for example, add it to the Color Manager node), execute them, and save the workflow. With the Interactive HiLite Collector node, you can add custom information to the currently highlighted rows, so that later you can identify multiple subsets (if you check the New Column box before clicking on Apply). Do not forget to execute the node, and later save the workflow once you are satisfied with your selection.

Variable flows

When you bring your mouse cursor to the left and upper-right corner of the nodes (a bit outside of it), you will get a different tooltip—Variable Inport and Variable Outport (Variables Connection) respectively. Something useful is hidden there. Select a node, and from the context menu, select Show Flow Variable Ports. This way two circles will appear filled with the color red. You can connect them to the other node's input/output flow ports. These connections are red. This way you can make sure the proper set of variables will be available at the right time (circular dependencies are not allowed this way). The loops also use the workflow variables, and there are multiple nodes to create these or change them. You seldom need these connections as flow variables are propagated through normal connections.

You can also specify workflow variables from the context menu of the workflow (Workflow Variables...), or by using the QuickForm nodes.

Meta nodes

We mentioned that the meta nodes are useful for encapsulating the parts of the workflow and to hide the distracting details. The quickstart.pdf file gives a nice introduction to meta nodes; you can find the content on the web too at the link http://tech.knime.org/metanodes.

An unmentioned option to create new meta nodes is by selecting a closed subset of non-executed nodes or meta nodes and invoking the Collapse into Meta Node action from the context menu. The opposite process (bringing the contents of the meta node to the current level) is also possible with the Expand Meta Node context menu item.

Opening a meta node is possible by double-clicking on it or selecting the Open Meta Node context menu item. Both ways, another workflow editor tab will appear, where you can continue the workflow design.

Workflow lifecycle

Once you have a workflow, you might want to save the changes you made and the computed data and models. That is really easy; navigate to File | Save (Ctrl + S) or use the toolbar's disc icon.


You cannot save workflows with executing nodes, so you have to save them before or later, else you have to stop the execution.

Sometimes you want to execute the whole workflow. To do that, you can use the toolbar's Execute all executable nodes button (a fast forward icon with a green circle background, Shift + F8) or the Node | Execute All menu item.


Batch processing

To process workflows from the command line (or from other program), the KNIME FAQ gives a good description at the following link: http://tech.knime.org/faq#q12

If there are multiple entry points to your workflow, it can be boring to reset all those nodes one by one, but the Reset command from the context menu of KNIME Explorer will reset all the nodes in the selected workflow.

Other views

The Server Workflow Projects view shows only the workflows (and groups) available on servers, but the Workflow Projects view shows only the local ones. If you do not need server workflows, this might be a better choice than the KNIME Explorer view, as this is more compact.

KNIME Node Monitor (View | Other... | KNIME Views) view gives you information about the selected item's state and other parameters. I think you will find this useful, especially if you explore the dropdown menu from the white triangle:

KNIME Node Monitor's possible contents



In this chapter, we have installed KNIME, set it up for its first usage, configured it, and installed a few extensions. We also went through the most important concepts you will use. We started using the workflow editor and executed our first workflow. Now it is time for you to check some of the example workflows from the KNIME public server and try to execute and modify them.

About the Author
  • Gábor Bakos

    Gábor Bakos is a programmer and a mathematician, having a few years of experience with KNIME and KNIME node development (HiTS nodes and RapidMiner integration for KNIME). In Trinity College, Dublin, the author was helping a research group with his data analysis skills (also had the opportunity to improve those), and with the new KNIME node development. When he worked for the evopro Kft. or the Scriptum Informatika Zrt., he was also working on various data analysis software products. He currently works for his own company, Mind Eratosthenes Kft. (www.mind-era.com), where he develops the RapidMiner integration for KNIME (tech.knime.org/community/rapidminer-integration), among other things.

    Browse publications by this author
Latest Reviews (6 reviews total)
La livraison a été un peu longue. Une dizaine de jours environ. A part ça, rien à dire, merci. Charly Clément.
Every thing is good. Packt may please publish more books on data science using Rapidminer and matlab.
Very basic introduction to KNIME platform for data analysis. It's a quick and easy way to start using this wonderful tool. Not so useful for people with previous experience.
KNIME Essentials
Unlock this book and the full library FREE for 7 days
Start now