使用LSTM和ResNet的无监督多模态分类

已于 2023-03-15 16:05:59 修改
阅读量4k 收藏 30
点赞数 6
文章标签： lstm python
于 2022-08-24 21:22:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ridgelu/article/details/126512365
版权

目录

前言

这是我第一次在csdn上写文章，做的东西只能算是学校的一些作业，如果有什么问题请大家多多指教。
这次做的是一个结合图像和对应短文本的无监督分类模型，使用的数据集来源于nus-wide，是一个来源于flickr的数据集，图片和文本一一对应，并对数据进行了分类

文本特征提取模型

在文本特征方面，使用变分自编码器和BiLSTM结合来提取文本的特征。将文本先用genism转变为向量，每一条文本经过词嵌入的过程后变为形状为(40,100)的矩阵，将矩阵输入变分自编码器中，进行1000轮的训练，获取编码器的输出，即可获得压缩为(100,)的文本特征。将此时的z_mean作为kmeans的输入进行分类，准确率大概是60%不到，效果不能说是非常差，但总的来说挺不咋地。
下面展示一些 乱七八糟的代码。

import matplotlib
import keras.callbacks
from keras import metrics
from keras.optimizers import adadelta_v2,adam_v2
from keras.layers import Conv2D, Conv2DTranspose, Input,Conv1D,Conv1DTranspose,MaxPooling1D,UpSampling1D, Flatten, Dense, Lambda, Reshape,LSTM,RepeatVector,TimeDistributed,Bidirectional,Dropout
# from keras.layers import BatchNormalization
from keras.losses import binary_crossentropy
from keras.activations import tanh, softmax
from keras.models import Model
from keras.datasets import mnist
from keras import backend as K
import numpy as np
import matplotlib.pyplot as plt
from keras.saving.save import load_model
from matplotlib import style
from sklearn.cluster import KMeans
from tensorflow.python.framework.ops import disable_eager_execution
disable_eager_execution()
# Load MNIST
from sklearn.model_selection import train_test_split
matplotlib.use('TKAgg')


# Normalize and reshape ============
class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self.losses = {'batch':[], 'epoch':[]}
        #self.accuracy = {'batch':[], 'epoch':[]}
        self.val_loss = {'batch':[], 'epoch':[]}
        #self.val_acc = {'batch':[], 'epoch':[]}

    def on_batch_end(self, batch, logs={}):
        self.losses['batch'].append(logs.get('loss'))
        #self.accuracy['batch'].append(logs.get('acc'))
        self.val_loss['batch'].append(logs.get('val_loss'))
        #self.val_acc['batch'].append(logs.get('val_acc'))

    def on_epoch_end(self, batch, logs={}):
        self.losses['epoch'].append(logs.get('loss'))
        #self.accuracy['epoch'].append(logs.get('acc'))
        self.val_loss['epoch'].append(logs.get('val_loss'))
        #self.val_acc['epoch'].append(logs.get('val_acc'))

    def loss_plot(self, loss_type):
        iters = range(len(self.losses[loss_type]))
        plt.figure()
        # acc
        #plt.plot(iters, self.accuracy[loss_type], 'r', label='train acc')
        # loss
        plt.plot(iters, self.losses[loss_type], 'r', label='train loss')
        if loss_type == 'epoch':
            # val_acc
            #plt.plot(iters, self.val_acc[loss_type], 'b', label='val acc')
            # val_loss
            plt.plot(iters, self.val_loss[loss_type], 'b', label='val loss')
        plt.grid(True)
        plt.xlabel(loss_type)
        plt.ylabel('loss')
        plt.legend(loc="upper right")
        plt.show()
# Norm.

train_x = np.load('')

#print(train_x)
#train_x = np.load('')
train_x = train_x.astype("float32")
train_x=np.random.permutation(train_x)
#train_x=train_x[0:,0:400]
print(train_x.shape)
#train_x=train_x.reshape((1040,1,400))
#print(train_x.shape)
train_y=np.load('')
# Reshape
''
input_shape = (train_x.shape[1],train_x.shape[2])
print(input_shape)



latent_dim = 3


input_txt = Input(shape=input_shape, name='encoder_input')
x=Dropout(rate=0.2)(input_txt)
x=Bidirectional(LSTM(50,activation='relu',recurrent_activation='sigmoid',recurrent_dropout=0,unroll=False,use_bias=False,name='LSTM'))(x)
#x=Bidirectional(LSTM(128,activation=tanh,input_shape=input_shape,name='LSTM'))(x)
#z_test=Dense(3,name="test")(x)
#x=Dense(200,activation='relu',name='Dense1')(x)
#t=Dense(100,activation='relu')(x)
z_mu = Dense(latent_dim, name='latent_mu')(x)  # Mean values of encoded input
z2=Lambda(softmax,output_shape=(latent_dim,),name='z2')(z_mu)
z_sigma = Dense(latent_dim ,name='latent_sigma')(x)  # Std dev. (variance) of encoded input

def sample_z(args):
    z_mu, z_sigma = args
    eps = K.random_normal(shape=(K.shape(z_mu)[0], K.int_shape(z_mu)[1]))
    return z_mu + K.exp(z_sigma / 2) * eps
'''def sample_z(args):#仅做尝试，上面那个才是要用的
    z_mu, z_sigma = args
    #batch_size = tf.shape(z_mu)[0]
    eps = K.random_normal(shape=(K.shape(z_mu)[0], K.int_shape(z_mu)[1]),mean=0,stddev=1)
    return z_mu + z_sigma * eps'''


z = Lambda(sample_z, output_shape=(latent_dim,), name='z')([z_mu, z_sigma])
#t=Dense(latent_dim,name='test',activation=softmax)(z)
#t=Lambda(softmax,output_shape=(latent_dim,))(z)

encoder = Model(input_txt, [ x,z_mu, z_sigma, z,z2], name='encoder')
encoder.summary()

# ================= ###########
# Decoder

decoder_input = Input(shape=(latent_dim,), name='decoder_input')
#decoded=Dense(200)(decoder_input)#仅尝试
decoded = RepeatVector(train_x.shape[1], name='EmbeddingtoTimeSeries')(decoder_input)
decoded = Bidirectional(LSTM(50,name='DecoderLSTM1',activation='relu', return_sequences=True))(decoded) #intermediate dimensions
decoded=Dropout(rate=0.2)(decoded)

decoded=TimeDistributed(Dense(train_x.shape[2]))(decoded)

# Define and summarize decoder model

decoder = Model(decoder_input, decoded, name='decoder')
decoder.summary()

# apply the decoder to the latent sample
z_decoded = decoder(z)


# =========================
# Define custom loss
# VAE is trained using two loss functions reconstruction loss and KL divergence
# Let us add a class to define a custom layer with loss
class CustomLayer(keras.layers.Layer):

    def vae_loss(self, inputs, decoded):
        inputs=K.flatten(inputs)
        decoded=K.flatten(decoded)
        xent_loss = binary_crossentropy(inputs, decoded)
        kl_loss = -5e-2 * K.mean(1 + z_sigma - K.square(z_mu) - K.exp(z_sigma),axis=-1)
        return K.mean(xent_loss+kl_loss)
    


    # add custom loss to the class
    def call(self, inputs):
        x = inputs[0]
        z_decoded = inputs[1]
        loss = self.vae_loss(x, z_decoded)
        self.add_loss(loss, inputs=inputs)
        return x


# apply the custom loss to the input images and the decoded latent distribution sample
y = CustomLayer()([input_txt, z_decoded])
print(type(y))
vae = Model(input_txt, y, name='vae')

# Compile VAE
vae.compile(optimizer='adam', loss=None)#似乎adam效果最好
vae.summary()

# Train autoencoder
#reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, mode='auto')
#earlystopping = keras.callbacks.EarlyStopping(monitor='val_loss', verbose=1, patience=30, mode='auto',restore_best_weights=True)
#vae.fit(train_x,y=None, epochs=1000, batch_size=128,callbacks=[reduce_lr,earlystopping],validation_split=0.2)
history = LossHistory()
vae.fit(train_x,y=None, epochs=500, batch_size=64,callbacks=[history],validation_split=0.2)
history.loss_plot('epoch')
# =================
# Visualize results
# =================
# Visualize inputs mapped to the Latent space
# Remember that we have encoded inputs to latent space dimension = 2.
# Extract z_mu --> first parameter in the result of encoder prediction representing mean

x,mu, _, zz,sof_z = encoder.predict(test_x)#获取编码器的输出，x就是文本特征
#print(mu)
# Plot dim1 and dim2 for mu
if latent_dim==2:
    plt.figure(figsize=(6, 6))  
    plt.scatter(mu[:, 0], mu[:, 1], c=train_y, cmap='brg')
    plt.xlabel('dim 1')
    plt.ylabel('dim 2')
    plt.colorbar()
    plt.show()
else:
    style.use('ggplot')
    fig = plt.figure()
    ax1 = fig.add_subplot(111, projection='3d')
    ax1.scatter(mu[:, 0], mu[:, 1], mu[:, 2], c=train_y, marker='o')
    # defining x, y, z co-ordinates
    ax1.set_xlabel('x-axis')
    ax1.set_ylabel('y-axis')
    ax1.set_zlabel('z-axis')
    plt.show()

est = KMeans(n_clusters=3)
est.fit(mu)
k_label=est.labels_
np.savetxt('D:/vae_txt_k_label.txt',k_label)

图像特征提取

图像特征提取就直接用了预训练的resnet50，先用权重为imagenet的resnet50提取出长度2048的图像特征（这里要把resnet最后的dense层去掉），但这长度和文本特征实在是不搭，所以用自编码器给压缩一下，个人感觉用pca效果不如自编码器，所以用了自编码器，也懒得认真对比了，学校作业就随便搞搞了，总之把图像特征搞成100的长度。
下面是 代码。

import matplotlib
from matplotlib import style
import keras.callbacks
from keras import metrics
from keras.optimizer_v2 import adam
from keras.optimizers import adadelta_v2,adam_v2
from keras.layers import Conv2D, Conv2DTranspose, Input, Flatten, Dense, Lambda, Reshape, LSTM, RepeatVector, Bidirectional,\
    TimeDistributed, Bidirectional, Dropout, Conv1D, MaxPooling1D, UpSampling1D, Conv1DTranspose
# from keras.layers import BatchNormalization
from keras.losses import binary_crossentropy, sparse_categorical_crossentropy, categorical_crossentropy, mae, mse
from keras.activations import tanh, relu
from keras.models import Model, Sequential
from keras.datasets import mnist
from keras import backend as K
import numpy as np
import matplotlib.pyplot as plt
from keras.saving.save import load_model
from sklearn.cluster import KMeans
from tensorflow.python.framework.ops import disable_eager_execution
disable_eager_execution()
# Load MNIST
from sklearn.model_selection import train_test_split
matplotlib.use('TKAgg')
feature=np.load("")
feature=feature.astype("float32")
#print(feature)
feature=np.random.permutation(feature)
print(feature.shape)
#print(feature)
#print(feature.dtype)
train_x=feature[0:,0:2048]
print(train_x.shape)
#train_x=train[0]
#train_x=train_x.reshape((1040,1,2048))
train_y=feature[0:,2048:2049]
print(train_y.shape)
#reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_loss',factor=0.1, patience=30, mode='auto')
#earlystopping = keras.callbacks.EarlyStopping(monitor='val_loss', verbose=1, patience=30,mode='auto',restore_best_weights=True)
# Reshape
class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self.losses = {'batch':[], 'epoch':[]}
        #self.accuracy = {'batch':[], 'epoch':[]}
        self.val_loss = {'batch':[], 'epoch':[]}
        #self.val_acc = {'batch':[], 'epoch':[]}

    def on_batch_end(self, batch, logs={}):
        self.losses['batch'].append(logs.get('loss'))
        #self.accuracy['batch'].append(logs.get('acc'))
        self.val_loss['batch'].append(logs.get('val_loss'))
        #self.val_acc['batch'].append(logs.get('val_acc'))

    def on_epoch_end(self, batch, logs={}):
        self.losses['epoch'].append(logs.get('loss'))
        #self.accuracy['epoch'].append(logs.get('acc'))
        self.val_loss['epoch'].append(logs.get('val_loss'))
        #self.val_acc['epoch'].append(logs.get('val_acc'))

    def loss_plot(self, loss_type):
        iters = range(len(self.losses[loss_type]))
        plt.figure()
        # acc
        #plt.plot(iters, self.accuracy[loss_type], 'r', label='train acc')
        # loss
        plt.plot(iters, self.losses[loss_type], 'r', label='train loss')
        if loss_type == 'epoch':
            # val_acc
            #plt.plot(iters, self.val_acc[loss_type], 'b', label='val acc')
            # val_loss
            plt.plot(iters, self.val_loss[loss_type], 'b', label='val loss')
        plt.grid(True)
        plt.xlabel(loss_type)
        plt.ylabel('loss')
        plt.legend(loc="upper right")
        plt.show()
#input_shape = (train_x.shape[1],train_x.shape[2])
input_shape=(2048,)
#adam1=adam_v2.Adam(learning_rate=0.001,decay=0.001)
model = Sequential()
model.add(Input(shape=input_shape,name="input"))

model.add(Dense(100,activation='relu',name='bidirectional'))
#model.add(Dropout(rate=0.2))
model.add(Dense(3,name='dense1'))

model.add(Dense(100,activation='relu'))

model.add(Dense(2048))
#model.add(Bidirectional(LSTM(50,activation='relu' ,return_sequences=True)))

#model.add(TimeDistributed(Dense(train_x.shape[2])))
#model.compile(optimizer='adam', loss=categorical_crossentropy,metrics=['accuracy'])
model.compile(optimizer='adam', loss=mse)
model.summary()

# fit model

#model.fit(train_x, train_x, epochs=200,callbacks=[reduce_lr,earlystopping], batch_size=64, validation_split=0.2)
history=LossHistory()
model.fit(train_x, train_x, epochs=500, callbacks=[history],batch_size=64)
history.loss_plot('epoch')
encoder=Model(inputs=model.get_layer('bidirectional').input,outputs=model.get_layer('dense1').output)
encoder2=Model(inputs=model.get_layer('bidirectional').input,outputs=model.get_layer('bidirectional').output)

model.save_weights("",encoder2)
mu= encoder.predict(train_x)


style.use('ggplot')
fig = plt.figure()
ax1 = fig.add_subplot(111, projection='3d')
ax1.scatter(mu[:, 0], mu[:, 1],mu[:, 2], c = train_y, marker = 'o')
# defining x, y, z co-ordinates
ax1.set_xlabel('x-axis')
ax1.set_ylabel('y-axis')
ax1.set_zlabel('z-axis')
plt.show()
'''plt.figure(figsize=(6, 6))
plt.scatter(mu[:, 0], mu[:, 1], c=train_y, cmap='brg')
plt.xlabel('dim 1')
plt.ylabel('dim 2')
plt.colorbar()
plt.show()'''
feature=np.load("")
feature=feature.astype("float32")
#print(feature)
#feature=np.random.permutation(feature)
#print(feature.shape)
#print(feature)
#print(feature.dtype)
x=feature[0:,0:2048]
ae_pic_feature=encoder2.predict(x)
est = KMeans(n_clusters=3)
est.fit(mu)
k_label=est.labels_

总体分类

先把上面两个模型的输出用concatenate拼接一下，让长度变成200，然后丢到vae里面，再把输出的结果用kmeans聚个类，基本上就搞定了
下面是 vae代码。

import keras
import matplotlib
import tensorflow as tf
from keras import metrics
from keras.backend import softmax
from keras.optimizers import adadelta_v2,adam_v2
from keras.layers import Conv2D, Conv2DTranspose, Input, Flatten, Dense, Lambda, Reshape,LSTM,RepeatVector,TimeDistributed,Bidirectional,Dropout
# from keras.layers import BatchNormalization
from keras.losses import binary_crossentropy
from keras.activations import tanh#,softmax
from keras.models import Model
from keras.datasets import mnist
from keras import backend as K
from mpl_toolkits.mplot3d import axes3d
import matplotlib.pyplot as plt
from matplotlib import style
import numpy as np
from keras import callbacks
import matplotlib.pyplot as plt
from keras.saving.save import load_model
from sklearn.cluster import KMeans
from sklearn.preprocessing import MinMaxScaler
from tensorflow.python.framework.ops import disable_eager_execution
disable_eager_execution()
# Load MNIST
from sklearn.model_selection import train_test_split
matplotlib.use('TKAgg')
#(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Normalize and reshape ============
class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self.losses = {'batch':[], 'epoch':[]}
        #self.accuracy = {'batch':[], 'epoch':[]}
        self.val_loss = {'batch':[], 'epoch':[]}
        #self.val_acc = {'batch':[], 'epoch':[]}

    def on_batch_end(self, batch, logs={}):
        self.losses['batch'].append(logs.get('loss'))
        #self.accuracy['batch'].append(logs.get('acc'))
        self.val_loss['batch'].append(logs.get('val_loss'))
        #self.val_acc['batch'].append(logs.get('val_acc'))

    def on_epoch_end(self, batch, logs={}):
        self.losses['epoch'].append(logs.get('loss'))
        #self.accuracy['epoch'].append(logs.get('acc'))
        self.val_loss['epoch'].append(logs.get('val_loss'))
        #self.val_acc['epoch'].append(logs.get('val_acc'))

    def loss_plot(self, loss_type):
        iters = range(len(self.losses[loss_type]))
        plt.figure()
        # acc
        #plt.plot(iters, self.accuracy[loss_type], 'r', label='train acc')
        # loss
        plt.plot(iters, self.losses[loss_type], 'r', label='train loss')
        if loss_type == 'epoch':
            # val_acc
            #plt.plot(iters, self.val_acc[loss_type], 'b', label='val acc')
            # val_loss
            plt.plot(iters, self.val_loss[loss_type], 'b', label='val loss')
        plt.grid(True)
        plt.xlabel(loss_type)
        plt.ylabel('acc-loss')
        plt.legend(loc="upper right")
        plt.show()

# Norm.
'''x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train = x_train / 255
x_test = x_test / 255'''
feature=np.load("")#加载之前做好的特征

feature=feature.astype("float32")#使数据类型为float
test_x=feature[0:,0:200]
test_y=feature[0:,200:]
test_x=test_x.reshape((1457,1,200))
print(feature.shape)
feature=np.random.permutation(feature)

#print(feature)
#print(feature.dtype)
train=feature[0:,0:200]


#print(train)
train_x=train.reshape((1457,1,200))

# Reshape
input_shape = (train_x.shape[1],train_x.shape[2])#输入训练的形状为(1,400)
print(input_shape)



latent_dim = 3  # Number of latent dim parameters即为想要的主题数

input_txt = Input(shape=input_shape, name='encoder_input')
x=Dropout(rate=0.3)(input_txt)
x=Bidirectional(LSTM(100,activation=tanh,recurrent_activation='sigmoid',recurrent_dropout=0,unroll=False,use_bias=False,input_shape=input_shape,name='LSTM'))(x)

z_mu = Dense(latent_dim, name='latent_mu')(x)  # Mean values of encoded input
z_sigma = Dense(latent_dim ,name='latent_sigma')(x)  # Std dev. (variance) of encoded input

def sample_z(args):
    z_mu, z_sigma = args
    eps = K.random_normal(shape=(K.shape(z_mu)[0], K.int_shape(z_mu)[1]))
    return z_mu + K.exp(z_sigma / 2) * eps



z = Lambda(sample_z, output_shape=(latent_dim,), name='z')([z_mu, z_sigma])
#z=Lambda(softmax,output_shape=(latent_dim,))(z)

encoder = Model(input_txt, [ z_mu, z_sigma, z,t,z2], name='encoder')
encoder.summary()

# ================= ###########
# Decoder

decoder_input = Input(shape=(latent_dim,), name='decoder_input')
#decoded=Dense(200)(decoder_input)#仅尝试
decoded = RepeatVector(train_x.shape[1], name='EmbeddingtoTimeSeries')(decoder_input)
decoded = Bidirectional(LSTM(100,name='DecoderLSTM1',activation=tanh, return_sequences=True))(decoded) #intermediate dimensions
decoded=Dropout(rate=0.3)(decoded)
decoded=TimeDistributed(Dense(train_x.shape[2]))(decoded)

# Define and summarize decoder model

decoder = Model(decoder_input, decoded, name='decoder')
decoder.summary()

# apply the decoder to the latent sample
z_decoded = decoder(z)


# =========================
# Define custom loss
# VAE is trained using two loss functions reconstruction loss and KL divergence
# Let us add a class to define a custom layer with loss
class CustomLayer(keras.layers.Layer):

    def vae_loss(self, inputs, decoded):
        inputs=K.flatten(inputs)
        decoded=K.flatten(decoded)
        xent_loss = binary_crossentropy(inputs, decoded)
        kl_loss = -5e-2 * K.mean(1 + z_sigma - K.square(z_mu) - K.exp(z_sigma),axis=-1)
        
        return K.mean(xent_loss+kl_loss)
    


    # add custom loss to the class
    def call(self, inputs):
        x = inputs[0]
        z_decoded = inputs[1]
        loss = self.vae_loss(x, z_decoded)
        self.add_loss(loss, inputs=inputs)
        return x


# apply the custom loss to the input images and the decoded latent distribution sample
y = CustomLayer()([input_txt, z_decoded])
print(type(y))
vae = Model(input_txt, y, name='vae')

# Compile VAE
vae.compile(optimizer='adam', loss=None)#似乎adam效果最好
vae.summary()

# Train autoencoder
history = LossHistory()
vae.fit(train_x,y=None, epochs=1000,callbacks=[history], batch_size=64,validation_split=0.2)
history.loss_plot('epoch')
# =================
# Visualize results
# =================
# Visualize inputs mapped to the Latent space
# Remember that we have encoded inputs to latent space dimension = 2.
# Extract z_mu --> first parameter in the result of encoder prediction representing mean

mu, _, zz, t,z_2 = encoder.predict(test_x)#获取编码器的输出
#encoder.save_weights('')
est = KMeans(n_clusters=3)
est.fit(mu)
#print(mu.shape)
#a=est.predict(mu[0:1])
#print(a)
'''joblib.dump(est, 'D:/keyan/source/model/Kmeans11.pkl')

# 载入模型
kmeans = joblib.load('')
labels = kmeans.labels_'''
labels=est.labels_
print(labels)
np.savetxt('',labels)
style.use('ggplot')
fig = plt.figure()
ax1 = fig.add_subplot(111, projection='3d')
ax1.scatter(z_2[:, 0],z_2[:, 1],z_2[:, 2], c = test_y, marker = 'o')
# defining x, y, z co-ordinates
ax1.set_xlabel('x-axis')
ax1.set_ylabel('y-axis')
ax1.set_zlabel('z-axis')
plt.show()
style.use('ggplot')
fig = plt.figure()
ax2 = fig.add_subplot(111, projection='3d')
ax2.scatter(z_2[:, 0], z_2[:, 1],z_2[:, 2], c = labels, marker = 'o')
# defining x, y, z co-ordinates
ax2.set_xlabel('x-axis')
ax2.set_ylabel('y-axis')
ax2.set_zlabel('z-axis')
plt.show()

总结

最后和本身数据集的标签对比下，分类的准确率在0.845，效果就那样吧，只是相对这个做个记录。

新增

在VAE的encoder的z后面加个softmax函数，把z拍到一个平面上就可以当主题模型用了，可以看出不同类别主题的占比

Ridge Lu
关注
多模态数据融合技术的理论基础与人工智能的创新应用
一键难忘的博客
02-02 3280
多模态AI指的是利用多种数据模态（如文本、图像、音频等）进行联合学习的人工智能系统。不同模态的数据通常包含互补的信息，合并这些信息可以帮助AI更好地理解复杂的情境和任务。例如，在视频内容理解中，图像、语音和文本（如字幕）三种模态的信息融合，可以让AI更精准地进行分类、情感分析或情境预测。
ResNetLSTM 项目使用教程
gitblog_00815的博客
09-13 1005
ResNetLSTM 项目使用教程 项目地址:https://gitcode.com/gh_mirrors/re/ResNetLSTM 1. 项目目录结构及介绍 ResNetLSTM/ ├── data/ │ ├── final_result/ │ └── pictures/ ├── README.md ├── ResLSTM.py ├── adjacency.csv ├── load_d...
ResNet结合LSTM王炸创新！最新SOTA方案预测准确率超91%
学姐带你玩AI的博客
05-20 2456
它能够同时处理图像的空间特征和时间序列数据。具体来说，通过结合ResNet在提取空间特征上的强大能力和LSTM在处理时间序列数据上的优势，我们可以在处理同时包含空间和时间信息的复杂数据时，这种结合不仅，还扩展了其应用范围。比如一种用来预测癫痫发作的预训练模型的方法，该方法结合了监督对比学习和混合模型，包括ResNet和LSTM。在CHB-MIT数据集上的实验表明，该模型在15分钟预发作期的预测中展现了SOTA性能，准确率达到91.90%，敏感性为89.64%。本文整理了。
多模态记忆融合：基于LSTM的连续场景生成——突破AI视频生成长度限制
最新发布
好看资源网的博客
04-19 783
本方案突破了AI视频生成的"记忆屏障"，实验显示生成的120分钟影片在观众调查中被误认为真人拍摄的比例达63%。值得关注的是，系统在生成过程中会自发创建跨场景的视觉隐喻（如用天气变化暗示剧情转折）。通过调整mem_dim参数，开发者可在创作自由度与资源消耗间找到最佳平衡。
无监督学习的多模态学习
AI天才研究院
12-31 591
1.背景介绍 无监督学习是一种机器学习方法，它不需要预先标记的数据集来训练模型。相反，它通过分析数据的结构和模式来自动发现特征和模式。无监督学习可以应用于各种问题，如聚类分析、降维、异常检测等。 多模态学习是一种机器学习方法，它涉及多种不同类型的数据。例如，图像、文本、音频和视频等。多模态学习的目标是从多种数据类型中学习共同的知识，以便在新的数据类型上进行预测和分类。 无监督学习的多模态学习...
无监督分类
爱吃火锅的博客
02-06 3627
目录 前言： 标签名称替换 类别预测 自训练 总结 前言： 在训练模型的时候，比如分类任务等等，都需要有标签数据进行监督学习，即使是要少量的标签数据，也可采用半监督的方式来提高模型的泛化性，关于一些最新的半监督学习可以参看笔者另一篇博客： 《半监督小样本数据学习》：https://blog.csdn.net/weixin_42001089/article/details/113307918 但是今天要分享的这篇论文是EMNLP20论文《Text Classification Usin.
ResNet + LSTM：同时处理空间和时间信息的数据时（如癫痫）的SOTA算法
Debroon
05-27 4193
这篇论文的主要贡献包括提出了一种预处理方法以增强特征提取，通过预训练图像表示来获得有限数据下的最佳性能，并引入了一种结合了ResNet和LSTM的混合模型，以提取时间序列图像数据的多样特征。EEG数据的预处理步骤：展示了单个通道EEG数据的预处理过程，包括原始EEG数据的转换为频谱图像（使用STFT），并进一步的数据增强技术，如频带截断和临时割除。通过这些阶段的处理，可以有效地从复杂的EEG数据中提取有用的信息，并训练出一个鲁棒的机器学习模型，最终提高癫痫管理和治疗的能力。
Pytorch(5): LeNet，ResNet，RNN，LSTM代码
JJJJJJames的博客
02-02 1100
1、 LeNet5与ResNet18实战 第一部分：LeNet5代码： import torch from torch import nn from torch.nn import functional as F class Lenet5(nn.Module): def __init__(self): super(Lenet5, self).__init__() self.conv_unit=nn.Sequential( nn.Con
基于 DeepSeek 实现多模态（文本 - 图像描述）处理的 Python 源码
01-27
这些框架中预训练好的网络模型，如VGG、ResNet用于图像特征提取，以及RNN、LSTM、Transformer用于文本处理，都可以被直接用于构建多模态模型。研究人员可以在此基础上进行微调，以适应特定的多模态任务。 多模态...
LSTM在视频分类中的原理与实践
AI天才研究院
04-06 1285
序列建模: LSTM能够有效地对视频帧序列进行建模，捕捉视频中的时序信息。特征提取: LSTM可以自动学习视频帧序列中的特征表示，无需手动设计特征。端到端训练: LSTM可以与其他深度学习模型（例如卷积神经网络）进行端到端训练，从而实现更好的分类性能。LSTM可以用于生成视频的简短摘要，例如提取视频中的关键帧、生成视频的文字描述等。LSTM作为一种强大的序列模型，在视频分类任务中取得了显著的成果。LSTM能够有效地捕捉视频中的时序信息，并可以与其他深度学习模型进行端到端训练。
基于三维卷积和卷积LSTM的多模态手势识别
02-06
手势识别的目的是识别人体有意义的动作，在智能人机交互中至关重要。本文提出了一种基于三维卷积和卷积长短时记忆(LSTM)网络的多模态手势识别方法。该方法首先通过三维卷积神经网络学习手势的短期时空特征，然后在提取的短期时空特征的基础上，通过卷积LSTM网络学习长期时空特征。此外，我们评估了多模态数据之间的微调，我们发现，当没有预先训练的模型存在时，它可以被视为一种可选的技能，以防止过拟合。在ChaLearn LAP大规模孤立手势数据集(IsoGD)和Sheffield Kinect手势数据集(SKIG)上对该方法进行了验证。结果表明，该方法在IsoGD验证集上的识别准确率为51.02%，在SKIG验证集上的识别准确率为98.89%。 3d卷积，卷积LSTM，手势识别，多模态
论文，ICCV17c-基于层次化多模态LSTM的视觉语义联合嵌入
11-16
ICCV2017c入选论文-基于层次化多模态LSTM的视觉语义联合嵌入，Hierarchical Multimodal LSTM for Dense Visual-Semantic Embedding。找了好半天才找到。CSDN最低资源分为2，我只好设置成最低的了。版权归原作者和其单位所有。【上次遇到了系统自动增加资源分的情况，要怪就怪CSDN网站。】
机器学习的分类——无监督学习（Unsupervised Learning）
guojunwu1977的博客
03-28 3504
无监督学习（Unsupervised Learning）是机器学习中的一种重要分类，它与监督学习的主要区别在于训练数据没有标签。无监督学习的目的是探索数据本身的结构和模式，而不是预测或分类具体的输出。这种学习方式对于发现数据中的隐藏模式和关系特别有用。
无监督学习分类
m0_37998477的博客
12-18 3137
无监督学习 把输入数据看成一个行（m）为特征，列（N）为样本的矩阵。则从数据角度，可以将无监督学习分为三类。 将数据按列划分，即将相似的样本聚到同类，即对数据进行聚类，代表算法k-means，层次聚类。 将数据按行划分，把高维空间的向量转化到低维空间的向量，即对数据进行降维，代表算法主成分分析（PCA）。 同时考虑数据的纵向和横向结构，假设数据由某个概率模型生成，通过数据学习该概率模型，代表算法PageRank算法。 ...
简单易懂无监督分类算法：Kmeans, MiniBatchKmeans和DBSCAN
yonsan_的博客
12-23 650
DBSCAN与KMeans不同，它是一种基于密度分类的聚类算法。
ResNet+LSTM实现对视频的时序信息识别
热门推荐
luoye2333的博客
09-03 2万+
目录一、简介1.卷积网络提取特征2.LSTM实现记忆2.3.代码 一、简介   如何用神经网络把视频中的时序特征提取出来？比如说某个物体的摆动拍成了视频，输出它的频率；或者时间的长短；或者更高级的信息。   这篇文章就是把卷积网络ResNet和记忆性网络LSTM结合在一起，实现对视频段的信息识别。直接灵感来源于一篇国外论文[1]，但是我相信这种应用肯定很多很多人已经做过了。我写这篇文章的目的就是帮...
多模态多分类问题简单基线
03-18
<think>嗯，用户想找一个解决多模态多分类问题的简单基线方法或模型。我需要先理解什么是多模态多分类问题。多模态应该是指数据来自不同的模态，比如文本、图像、音频等，而多分类则是目标变量有多个类别需要预测。简单基线方法的话，可能是指容易实现、计算资源要求不高的模型。 首先，用户可能希望有一个整合不同模态数据的方法，然后进行分类。常见的做法可能有早期融合、晚期融合，或者中间融合。早期融合就是把不同模态的特征在输入层拼接起来，然后输入到一个分类器里。这种方法简单，但可能忽略模态间的复杂交互。比如，引用中提到Qwen-VL就是结合了文本和视觉模型，所以可能需要类似的结构。 另一个方法是使用多模态Transformer，比如CrossAttention，这属于中间融合。引用里提到CrossAttention允许模型在处理一个序列时关注另一个序列，这可能适用于多模态任务。比如CLIP模型就是处理图像和文本的对齐，可能可以借鉴。 然后，用户需要的是简单的基线，所以可能需要更轻量级的模型。比如，特征拼接后接一个全连接层，或者使用预训练的单模态模型提取特征，再融合。比如，用ResNet提取图像特征，BERT提取文本特征，然后拼接起来输入分类器。 另外，引用中有一篇关于多模态语言模型做目标检测的文章，方法是将检测输出转为文本形式，微调多模态模型。这可能类似将不同模态的数据转换为统一表示，然后进行分类。这种方法是否适用呢？可能需要将各个模态的特征编码成文本或向量，然后输入到分类模型里。 还需要考虑数据模态的类型，如果包含图像和文本，可能需要分别处理这两个模态的特征，再融合。比如，使用预训练的视觉模型和语言模型，然后融合它们的特征向量。 可能还需要考虑不同融合方式的优缺点。早期融合计算量大，但可能捕捉更多交互；晚期融合更灵活，但可能丢失模态间细节。中间融合，如CrossAttention，可能平衡两者，但实现稍复杂。 用户可能需要一个代码示例，比如用PyTorch实现早期融合，或者用Hugging Face的Transformer库实现CrossAttention。需要确保示例简单，符合用户需求。 另外，引用里提到原生多模态模型和多个单模型拼接的区别。用户可能倾向使用后者作为基线，因为实现起来更简单。比如，分别用单模态模型提取特征，再拼接，然后训练一个分类器。这种方法资源要求低，适合作为基线。 总结可能的方案： 1. 特征拼接（早期融合） 2. 投票或加权平均（晚期融合） 3. 使用多模态Transformer（如CrossAttention） 4. 预训练单模态模型+微调分类层 需要评估哪种最简单。特征拼接和晚期融合应该是最容易实现的。比如，用预训练的ResNet和BERT提取特征，拼接后输入全连接层，代码示例可以展示这一点。 可能的问题：如何处理不同模态的特征维度不同？可能需要降维或标准化。比如，对图像特征和文本特征分别进行PCA或LayerNorm，再拼接。 另外，数据预处理部分也需要考虑，比如图像如何resize，文本如何分词。但用户可能希望简化这部分，使用现有的预训练模型处理。 最后，需要给出相关的问题，比如如何选择融合方式，如何处理模态不平衡，如何评估多模态模型性能等。</think>### 多模态多分类问题的简单基线方法 #### 1. **特征拼接+单分类器（早期融合）** 将不同模态的特征提取后拼接为一个联合特征向量，再输入分类器。这是最简单的基线方法。 - **实现步骤**： 1. 对每个模态使用预训练模型提取特征（例如：图像用ResNet，文本用BERT，音频用VGGish）。 2. 将特征向量归一化后拼接，例如：$f_{\text{joint}} = [f_{\text{image}}; f_{\text{text}}; f_{\text{audio}}]$。 3. 输入全连接层进行分类，例如：$y = \text{Softmax}(W \cdot f_{\text{joint}} + b)$。 ```python import torch from transformers import BertModel, BertTokenizer from torchvision.models import resnet50 # 图像特征提取 image_model = resnet50(pretrained=True) image_feature = image_model(torch.rand(1, 3, 224, 224)) # 输出维度: 1000 # 文本特征提取 text_model = BertModel.from_pretrained('bert-base-uncased') tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') text_input = tokenizer("example text", return_tensors="pt") text_feature = text_model(**text_input).last_hidden_state.mean(dim=1) # 输出维度: 768 # 特征拼接与分类 joint_feature = torch.cat([image_feature, text_feature], dim=1) # 合并后维度: 1768 classifier = torch.nn.Linear(1768, num_classes) output = classifier(joint_feature) ``` #### 2. **多模态Transformer（中间融合）** 使用CrossAttention机制融合不同模态特征，适合捕捉模态间复杂关系[^2]。 - **实现步骤**： 1. 为每个模态分配独立的编码器（如ViT、LSTM）。 2. 通过跨模态注意力层交互特征，例如：文本作为Query，图像作为Key/Value。 3. 将融合后的特征输入分类层。 ```python from transformers import ViTModel, BertModel, BertTokenizer import torch.nn as nn class CrossModalClassifier(nn.Module): def __init__(self, num_classes): super().__init__() self.image_encoder = ViTModel.from_pretrained('google/vit-base-patch16-224') self.text_encoder = BertModel.from_pretrained('bert-base-uncased') self.cross_attention = nn.MultiheadAttention(embed_dim=768, num_heads=8) self.classifier = nn.Linear(768, num_classes) def forward(self, image, text_input): image_feature = self.image_encoder(image).last_hidden_state.mean(dim=1) # 维度: 768 text_feature = self.text_encoder(**text_input).last_hidden_state # 维度: (seq_len, 768) # CrossAttention: 文本作为Query，图像作为Key/Value fused_feature, _ = self.cross_attention( query=text_feature, key=image_feature.unsqueeze(0), value=image_feature.unsqueeze(0) ) output = self.classifier(fused_feature.mean(dim=1)) return output ``` #### 3. **多模态语言模型微调（端到端方案）** 直接使用现有多模态模型（如Qwen-VL[^1]、CLIP[^2]），将分类任务转化为文本生成任务。例如，将标签映射为文本描述，通过生成结果判断类别。 - **示例流程**： ```python from transformers import AutoModelForCausalLM, AutoProcessor model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-VL") processor = AutoProcessor.from_pretrained("Qwen/Qwen-VL") # 输入图像和文本提示（如"这张图片的类别是："） inputs = processor(images=image, text="这张图片的类别是：", return_tensors="pt") outputs = model.generate(**inputs) predicted_class = processor.decode(outputs[0], skip_special_tokens=True) ``` #### 4. **加权投票或平均（晚期融合）** 对每个模态单独训练分类器，最终通过加权投票或概率平均得到结果。 - **优点**：实现简单，适合模态差异大的场景[^4]。 --- ### 关键设计建议 1. **模态对齐**：若模态间差异较大（如文本与遥感图像[^4]），需对特征进行归一化或降维。 2. **数据量影响**：小数据时推荐特征拼接，大数据可尝试端到端微调。 3. **评估方案**：需设计跨模态消融实验（如仅用图像/文本/多模态对比）。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值