TDengine + OpenVINO + AIxBoard，助力时序数据分类

from os import pathimport numpy as npfrom sklearn import preprocessing
from tensorflow import kerasfrom tensorflow.keras.layers import (    Activation, Add, BatchNormalization, Concatenate,    Conv1D, Dense, Input, GlobalAveragePooling1D, MaxPool1D)
from sqlalchemy import create_engine, text

def readucr(conn, dbName, tableName):    data = pd.read_sql(        text(            "select * from " + dbName + "." + tableName        ),        conn,    )    y = data[:, 0]    x = data[:, 1:]    return x, y
def load_data(db):    engine = create_engine("taos://root:taosdata@localhost:6030/" + db)    try:        conn = engine.connect()    except Exception as e:        print(e)        exit(1)
    if conn is not None:        print("Connected to the TDengine ...")    else:        print("Failed to connect to taos")        exit(1)
    x_train, y_train = readucr(conn, db + '_TRAIN.tsv')    x_test, y_test = readucr(conn, db + '_TEST.tsv')    n_classes = len(np.unique(y_train))    enc = preprocessing.OneHotEncoder()    y = np.concatenate((y_train, y_test), axis=0).reshape(-1,1)    enc.fit(y)    y_tr = enc.transform(y_train.reshape(-1,1)).toarray()    y_te = enc.transform(y_test.reshape(-1,1)).toarray()    x_tr, x_te = map(lambda x: x.reshape(x.shape[0], x.shape[1], 1), [x_train, x_test])    return x_tr, y_tr, x_te, y_te, n_classes
x_tr, y_tr, x_te, y_te, n_classes = load_data('Wafer')

def inception_module(input_tensor, filters, kernel_size, bottleneck_size,                     activation='relu', use_bottleneck=True):    if use_bottleneck and int(input_tensor.shape[-1]) > 1:        input_inception = Conv1D(filters=bottleneck_size, kernel_size=1, padding='same',                                 activation=activation, use_bias=False)(input_tensor)    else:        input_inception = input_tensor    kernel_size_s = [kernel_size // (2 ** i) for i in range(3)] # [40, 20, 10]    conv_list = []    for i in range(len(kernel_size_s)):        conv = Conv1D(filters=filters, kernel_size=kernel_size_s[i],                      strides=1, padding='same', activation=activation,                      use_bias=False)(input_inception)        conv_list.append(conv)    max_pool = MaxPool1D(pool_size=3, strides=1, padding='same')(input_tensor)    conv_6 = Conv1D(filters=filters, kernel_size=1, padding='same',                      activation=activation, use_bias=False)(max_pool)    conv_list.append(conv_6)    x = Concatenate(axis=2)(conv_list)    x = BatchNormalization()(x)    x = Activation(activation='relu')(x)    return x
def shortcut_layer(input_tensor, output_tensor):    y = Conv1D(filters=int(output_tensor.shape[-1]), kernel_size=1,               padding='same', use_bias=False)(input_tensor)    y = BatchNormalization()(y)    x = Add()([y, output_tensor])    x = Activation(activation='relu')(x)    return x
def build_model(input_shape, n_classes, depth=6,                filters=32, kernel_size=40, bottleneck_size=32,                use_residual=True):    input_layer = Input(input_shape)    x = input_layer    input_res = input_layer    for d in range(depth):        x = inception_module(x, filters, kernel_size, bottleneck_size)        if use_residual and d % 3 == 2:            x = shortcut_layer(input_res, x)            input_res = x    gap_layer = GlobalAveragePooling1D()(x)    output_layer = Dense(n_classes, activation="softmax")(gap_layer)    model = keras.Model(input_layer, output_layer)    return model
model = build_model(x_tr.shape[1:], n_classes)
model.compile(    optimizer='adam',    loss='categorical_crossentropy',    metrics=['accuracy'])

ckpt_path = path.sep.join(['.', 'models', 'inception_wafer.h5'])
callbacks = [    keras.callbacks.ReduceLROnPlateau(        monitor='val_loss', factor=0.5, patience=20, min_lr=0.0001    ),    keras.callbacks.EarlyStopping(monitor='val_loss', patience=20, verbose=1),    keras.callbacks.ModelCheckpoint(        filepath=ckpt_path, monitor='val_loss', save_best_only=True    )]
batch_size = 32epochs = 500
history = model.fit(x_tr, y_tr, batch_size, epochs, verbose='auto', shuffle=True, validation_split=0.2, callbacks=callbacks)

metric = 'accuracy'plt.figure(figsize=(10, 5))plt.plot(history.history[metric])plt.plot(history.history['val_'+metric])plt.title("model " + metric)plt.ylabel(metric, fontsize='large')plt.xlabel('epoch', fontsize='large')plt.legend(["train", "val"], loc="best")plt.show()plt.close()

classifier = keras.models.load_model(ckpt_path)test_loss, test_acc = classifier.evaluate(x_te, y_te)print("Test accuracy: ", test_acc)print("Test loss: ", test_loss)

193/193 [==============================] - 2s 11ms/step - loss: 0.0142 - accuracy: 0.9958Test accuracy:  0.9957819581031799Test loss:  0.014155667275190353

from pathlib import Pathfrom openvino.tools import mofrom tensorflow import keras
model = keras.models.load_model('models/inception_wafer.h5')
model_path = Path('models/inception.0_float')model.save(model_path)
model_dir = Path("ov")model_dir.mkdir(exist_ok=True)ir_path = Path("ov/inception.xml")
input_shape = [1, 152, 1]
if not ir_path.exists():    print("Exporting TensorFlow model to IR...")    ov_model = mo.convert_model(saved_model_dir=model_path, input_shape=input_shape, compress_to_fp16=True)    serialize(ov_model, ir_path)else:    print(f"IR model {ir_path} already exists.")

from pathlib import Pathimport numpy as npfrom openvino.runtime import Core, serialize

ir_path = Path("inception.xml")core = Core()model = core.read_model(ir_path)

import ipywidgets as widgets
device = widgets.Dropdown(    options=core.available_devices + ["AUTO"],    value='AUTO',    description='Device:',    disabled=False)
device

def readucr(filename, delimiter='\t'):    data = np.loadtxt(filename, delimiter=delimiter)    y = data[:, 0]    x = data[:, 1:]    y[y==-1] = 0    return np.expand_dims(x, axis=2), y
X, y = readucr('Wafer_TEST.tsv')
compiled_model = core.compile_model(model, device_name=device.value)
input_key = compiled_model.input(0)output_key = compiled_model.output(0)network_input_shape = input_key.shape
counter = 0for idx, i in enumerate(X):    i = np.expand_dims(i, axis=0)    r = compiled_model(i)[output_key]    counter += 1 if r.argmax() == y[idx] else 0
print('{:.6f}'.format(counter/len(y)))

0.995782