Machine Learning Classification uses models created in TensorFlow. See 

The TensorFlow Images Processor feeds images to an already created TensorFlow Model.

The TensorFlow Processor feeds timeseries data to an aready created TensorFlow Model.

This use case is a customized classification version of a CNN classification model from the TensorFlow website.

# cnn model
from numpy import mean
from numpy import std
from numpy import dstack
from pandas import read_csv
import numpy as np
import tensorflow as tf
from tensorflow import keras
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# load a single file as a numpy array
def load_file(filepath):
dataframe = read_csv(filepath, header=None, delim_whitespace=True)
return dataframe.values 

# load a list of files and return as a 3d numpy array
def load_group(filenames, prefix=''):
loaded = list()
for name in filenames:
data = load_file(prefix + name)
loaded.append(data) 
# stack group so that features are the 3rd dimension
loaded = dstack(loaded)
return loaded 

# load a dataset group, such as train or test
def load_dataset_group(group, prefix=''):
filepath = prefix + group + '/Inertial Signals/'
# load all 9 files as a single array
filenames = list() 
# total acceleration 
filenames += ['total_acc_x_'+group+'.txt', 'total_acc_y_'+group+'.txt', 'total_acc_z_'+group+'.txt']
body acceleration
filenames += ['body_acc_x_'+group+'.txt', 'body_acc_y_'+group+'.txt', 'body_acc_z_'+group+'.txt']
# body gyroscopefilenames += ['body_gyro_x_'+group+'.txt', 'body_gyro_y_'+group+'.txt', 'body_gyro_z_'+group+'.txt']
# load input data
X = load_group(filenames, filepath) 
load class output 
y = load_file(prefix + group + '/y_'+group+'.txt')
return X, y 

# load the dataset, returns train and test X and y elements
def load_dataset(prefix=''):
# load all train
trainX, trainy = load_dataset_group('train', prefix + 'HARDataset/')
print(trainX.shape, trainy.shape)
# load all test
testX, testy = load_dataset_group('test', prefix + 'HARDataset/')
print(testX.shape, testy.shape)
zero-offset class values
trainy = trainy - 1
testy = testy - 1
one hot encode y
trainy = tf.keras.utils.to_categorical(trainy)
testy = tf.keras.utils.to_categorical(testy)
print(trainX.shape, trainy.shape, testX.shape, testy.shape)
return trainX, trainy, testX, testy

# standardize data
def scale_data(trainX, testX, standardize):
# remove overlap
cut = int(trainX.shape[1] / 2)
longX = trainX[:, -cut:, :]
# flatten windows
longX = longX.reshape((longX.shape[0] * longX.shape[1], longX.shape[2]))
# flatten train and test
flatTrainX = trainX.reshape((trainX.shape[0] * trainX.shape[1], trainX.shape[2]))
flatTestX = testX.reshape((testX.shape[0] * testX.shape[1], testX.shape[2]))
# standardize
if standardize:
s = StandardScaler()
# fit on training data
s.fit(longX)
# apply to training and test data
longX = s.transform(longX)
flatTrainX = s.transform(flatTrainX)
flatTestX = s.transform(flatTestX)
# reshape
flatTrainX = flatTrainX.reshape((trainX.shape))
flatTestX = flatTestX.reshape((testX.shape))
return flatTrainX, flatTestX

# fit and evaluate a model
def evaluate_model(trainX, trainy, testX, testy, param, n_filters, kernal_size):
verbose, epochs, batch_size = 0, 10, 32
n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]

# scale data
trainX, testX = scale_data(trainX, testX, param)
model = keras.Sequential()
model.add(tf.keras.layers.Conv1D(filters=n_filters, kernel_size=kernal_size, activation='relu', input_shape=(n_timesteps,n_features)))
model.add(tf.keras.layers.Conv1D(filters=n_filters, kernel_size=kernal_size, activation='relu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.MaxPooling1D(pool_size=2))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(100, activation='relu'))
model.add(tf.keras.layers.Dense(n_outputs, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
# fit network
model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose)
# evaluate model
_, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
return accuracy, model

# summarize scores
def summarize_results(scores, params):
print(scores, params)
summarize mean and standard deviation
for i in range(len(scores)):
m, s = mean(scores[i]), std(scores[i])
print('Param=%s: %.3f%% (+/-%.3f)' % (params[i], m, s))
# boxplot of scores
# plt.boxplot(scores, labels=params)
# plt.savefig('exp_cnn_standardize.png')

# run an experiment
def run_experiment(params, repeats=1):
# load data
trainX, trainy, testX, testy = load_dataset()
# test each parameter
all_scores = list()
for p in params:
# repeat experiment
scores = list()
model = keras.Sequential()
for r in range(repeats):
score, model = evaluate_model(trainX, trainy, testX, testy, p, n_filters=64, kernal_size=3)
score = score * 100.0
model.summary()
# if p:
#   model.save("/motionModel/")
yy = model.predict(trainX)
print(np.round(yy,3))
print(testy)
print('>p=%s #%d: %.3f' % (p, r+1, score))
scores.append(score)
all_scores.append(scores)
# summarize results
summarize_results(all_scores, params)

### run the experiment
n_params = [False, True]
run_experiment(n_params)
# plt.show()

Machine Learning Prediction

Machine Learning Classification

Machine Learning Anomaly Detection

MC Technical Documentation

Manufacturing Connect Edge

User Journey

Overview

System Requirements

ISO Installation on Hypervisors

ISO Installation on an Industrial PC (IPC)

OVA Installation on Virtual Machine

Zerotouch Installation

Docker Installation

Kubernetes Installation

Software Updates

Installation and Deployments

Access the Terminal User Interface

Access the Manufacturing Connect Edge Web UI

Allen-Bradley

Atlas Copco

BACnet

Beckhoff

Brother Industries Ltd

CAN Bus

CodeSys Devices

Cutler-Hammer

Danfoss

Delta PLC

Emerson

Euromap63

Excel

Fanuc Corporation

Fuji Devices

GE Fanuc

GPIO

Heidenhain

HID Devices

Hitachi Devices

JTEKT Toyopuc

Keyence

Koyo

LS Industrial System

Mitsubishi

Modbus

MTConnect

MQTT

ODVA

Omron

OPC UA

Opto Devices

Panasonic

Parker

Ping

Profinet

RS Automation

SAIA

Sick Flexi

Siemens

Simulator

Toshiba

VIPA

Yaskawa

Yokogawa

Industrial Systems Connection Guide

Quickstart Guide

Dashboard

Devices

Device Discovery (Network)

Utilities

DeviceHub

Configure the Timeseries DB

DB Management

DB Users

DataHub

Create a Flow

Manage a Flows Manager

Manage the Flow Canvas

Function Nodes

Configuration Nodes

Flows Manager

Analytics Flows and Processors

Analytics Flow Groups

Instances Table

Machine Learning Models

Key Performance Indicators

Analytics

Applications Dashboard

Catalog Apps

Configure

Marketplace

Containers

Networks

Images

Registry

Volumes

System Info

Disk Usage

Applications

Add a Connector

Add Topics to Connectors

Manage Connectors

Integration Connectors

Integration

Hierarchy

Management

Connections

OPC UA Server

Info

Certificates

Network

Wi-Fi

Remote Access

Device Management

LDAP/AD Auth

Users

Tokens

Services

External Storage

Policy Management

Licenses

Events

Zerotouch

Support

Backup/Restore

System

Product Features

Organize Device and Tag Data by Using Metadata

Use the PLC-Status Topic to Verify Connection Status

Use the Manage Topic to Stop a Device

Use the Poll-Once Topic to Manually Retrieve Register Values

Use the Write Topic to Send Data to a PLC

Use the Batch-Write Topic to Send Multiple Write Requests

Use the Status Register to Connect a PLC

Use the Siemens S7 Browse Agent

Use the Mazak MTConnect Demo Agent to Connect a Device

DeviceHub Guides

Subscribe to Topics with Flows

Use Access to Read from a Topic

Use Access to Write to a Topic

Create, Write to, and Read from a Log File

Save Multiple Register Values to a CSV File

Work with SQL Databases

Work with MongoDB Databases

Write to Databases with Integration Topics

Create a Chart

Ping a Host

Send Alerts to a Mobile Phone

Create Audio Notifications for Sensor Readings

Flows Guides

Use the Anomaly Detection Function

Use the Base Conversion Function

Use the Combination Processor Function

Use the Conversion Function

Use the Expression Processor Function

Use the Feature Extractor Function

Use the Gaussian Filter Function

Use the Inputs Processor Function

Use the Join Processor Function

Use the Linear Prediction Function

Use the Moving Window Processor Function

Use the Normalization Processor Function

Use the Rise and Fall Function

Use the Rounding Function

Use the Signal Decomposition Function

Use the Statistical Prediction Function

Use the Statistical Tests Function

Use the Tengo Script Function

Use the XMR Chart Function

Use the Asset Online Percentage KPI

Use the Change of Value KPI

Use the Compliance and Loss KPI

Use the Maintenance and Failure KPI

Use the Manufacture Counter KPI

Use the Online and Offline Percentage KPI

Use the Production Time and Cycle Time Ratio KPI

Use the Uptime and Downtime by Value KPI

Analytics Guides

Visualize Data Using Grafana

Use Marketplace SDK with Python

Deploy and Use MySQL

Set Up the Influx Client for InfluxQL Queries

Add an Application Container Using Docker Compose

Applications Guides

AMQP SSL Integration Guide

AMQP TCP Integration Guide

Generic MQTT Integration Guide (HiveMQ)

Generic MQTT Integration Guide (Last Will and Testament)

Generic MQTT Integration Guide (Mosquitto)

Generic MQTT Over SSL Integration Guide (Mosquitto)

Google Cloud Pub/Sub Integration Guide

InfluxDB v1.7.x SSL Integration Guide

InfluxDB v1.7.x TCP Integration Guide

InfluxDB v2.x SSL Integration Guide

InfluxDB v2.x TCP Integration Guide

Install the Mosquitto MQTT Broker on Ubuntu

Integration Guides

Untitled