深度学习算法中的非线性独立成分分析（Nonlinear Independent Component Analysis in De

pythonCopy codeimport tensorflow as tf
# 定义NLICA模型
class NLICA:
    def __init__(self, input_dim, hidden_units):
        self.input_dim = input_dim
        self.hidden_units = hidden_units
        self.weights = []
        self.biases = []
        
        # 初始化权重和偏置
        for i in range(len(hidden_units)):
            if i == 0:
                w = tf.Variable(tf.random_normal([input_dim, hidden_units[i]]))
            else:
                w = tf.Variable(tf.random_normal([hidden_units[i-1], hidden_units[i]]))
            b = tf.Variable(tf.zeros([hidden_units[i]]))
            self.weights.append(w)
            self.biases.append(b)
        
    def forward(self, x):
        for i in range(len(self.hidden_units)):
            if i == 0:
                out = tf.add(tf.matmul(x, self.weights[i]), self.biases[i])
            else:
                out = tf.add(tf.matmul(out, self.weights[i]), self.biases[i])
            out = tf.nn.relu(out)  # 非线性激活函数
        return out
# 创建NLICA模型对象
input_dim = 784  # 输入维度
hidden_units = [256, 128, 64]  # 隐藏层单元数
model = NLICA(input_dim, hidden_units)
# 定义损失函数和优化器
loss_func = tf.losses.mean_squared_error
optimizer = tf.train.AdamOptimizer(learning_rate=0.001)
# 创建输入占位符
x = tf.placeholder(tf.float32, [None, input_dim])
# 构建模型
output = model.forward(x)
# 定义损失函数
loss = loss_func(labels=x, predictions=output)
# 定义优化目标
train_op = optimizer.minimize(loss)
# 加载数据集并训练模型
mnist = tf.keras.datasets.mnist
(x_train, _), (x_test, _) = mnist.load_data()
# 数据归一化
x_train = x_train / 255.0
x_test = x_test / 255.0
# 创建会话并初始化变量
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    
    # 迭代训练模型
    for epoch in range(100):
        avg_cost = 0.
        total_batch = int(x_train.shape[0] / batch_size)
        for i in range(total_batch):
            batch_x = x_train[i * batch_size:(i + 1) * batch_size, :]
            _, c = sess.run([train_op, loss], feed_dict={x: batch_x})
            avg_cost += c / total_batch
        print("Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost))
    
    # 在测试集上评估模型
    reconstruction = sess.run(output, feed_dict={x: x_test[:10, :]})
    
    # 打印重构结果
    for i in range(10):
        plt.subplot(2, 10, i+1)
        plt.imshow(np.reshape(x_test[i, :], (28, 28)), cmap='gray')
        plt.subplot(2, 10, i+11)
        plt.imshow(np.reshape(reconstruction[i, :], (28, 28)), cmap='gray')
    plt.show()

pythonCopy codeimport numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
# 将正常和异常样本分别标记为0和1
def label_data(data, normal_data):
    labels = np.zeros(data.shape[0])
    labels[normal_data.shape[0]:] = 1
    return labels
# 加载数据集
def load_dataset():
    # 加载正常样本和异常样本数据
    normal_data = np.loadtxt('normal_data.txt', delimiter=',')
    abnormal_data = np.loadtxt('abnormal_data.txt', delimiter=',')
    
    # 合并正常和异常样本数据
    data = np.concatenate((normal_data, abnormal_data), axis=0)
    
    # 标记数据
    labels = label_data(data, normal_data)
    
    # 划分训练集和测试集
    x_train, x_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=42)
    
    return x_train, x_test, y_train, y_test
# 定义NLICA异常检测模型
class NLICA_AnomalyDetection:
    def __init__(self, input_dim, hidden_units):
        self.input_dim = input_dim
        self.hidden_units = hidden_units
        self.weights = []
        self.biases = []
        
        # 初始化权重和偏置
        for i in range(len(hidden_units)):
            if i == 0:
                w = np.random.randn(input_dim, hidden_units[i])
            else:
                w = np.random.randn(hidden_units[i-1], hidden_units[i])
            b = np.zeros(hidden_units[i])
            self.weights.append(w)
            self.biases.append(b)
            
    def forward(self, x):
        for i in range(len(self.hidden_units)):
            if i == 0:
                out = np.dot(x, self.weights[i]) + self.biases[i]
            else:
                out = np.dot(out, self.weights[i]) + self.biases[i]
            out = np.maximum(out, 0)  # 非线性激活函数
        return out
# 加载数据集
x_train, x_test, y_train, y_test = load_dataset()
# 创建NLICA异常检测模型对象
input_dim = x_train.shape[1]  # 输入维度
hidden_units = [256, 128, 64]  # 隐藏层单元数
model = NLICA_AnomalyDetection(input_dim, hidden_units)
# 训练模型
output = model.forward(x_train)
# 使用训练好的模型对测试集进行预测
pred = model.forward(x_test)
# 预测结果为输出层的欧氏距离
dist = np.linalg.norm(pred - output, axis=1)
# 设置阈值来判断异常
threshold = np.percentile(dist, 95)  # 使用95%的分位数作为阈值
# 根据阈值判断样本是否异常
pred_labels = np.where(dist > threshold, 1, 0)
# 打印分类报告和混淆矩阵
print(classification_report(y_test, pred_labels))
print(confusion_matrix(y_test, pred_labels))