import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.models as models
import torchvision.transforms as transforms
from PIL import Image
import pandas as pd
import csv
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from gensim.models import Word2Vec,KeyedVectors
import jieba
import gensim
import os
import torch.nn.functional as F

# Обработка текстданных
text_df1 = pd.read_csv("Вложение 1/ImageWordData.csv")
# Определить функцию сегментации китайского слова
def Chinese_tokenizer(text):
    return list(jieba.cut(text))

# Выполните сегментацию китайских слов в заголовке
text_data1 = text_df1['caption'].apply(Chinese_tokenizer).tolist()

# Поскольку загрузка word2vec занимает очень много времени, требуется векторная локализация.
file_path = "word2vec/train_vocabulary_vector.csv"
if os.path.exists(file_path):
    # Чтение словаря - векторный словарь, csv в словарь
    vocabulary_vector = dict(pd.read_csv("word2vec/train_vocabulary_vector.csv"))
    # В это время необходимо восстановить данные типа вектора слов np.array в словаре до исходного типа для дальнейшего использования.
    for key,value in vocabulary_vector.items():
       vocabulary_vector[key] = np.array(value)
    word2vec_model = KeyedVectors.load('hy-tmp/train_bio_word',mmap='r')
else:
    # Прочитайте векторную модель слова на китайском языке (необходимо заранее скачать соответствующий файл Модель вектора слова)
    word2vec_model = KeyedVectors.load_word2vec_format('hy-tmp/word2vec.bz2', binary=False)
    word2vec_model.init_sims(replace=True)
    word2vec_model.save('hy-tmp/train_bio_word')
    
    # Постройте словарный запас из всего текста,words_cut Это список после сегментации слов, и каждый элемент отделяется пробелами изstr.
    vocabulary = list(set([word for item in text_data1 for word in item]))
    
    # Создание словарно-векторного словаря
    vocabulary_vector = {}
    for word in vocabulary:
       if word in word2vec_model:
          vocabulary_vector[word] = word2vec_model[word]
    # Храните словарь-векторный словарь. Поскольку файлы json не могут хорошо сохранять пустые векторы слов, используйте CSV для их сохранения.
    pd.DataFrame(vocabulary_vector).to_csv("word2vec/train_vocabulary_vector.csv")

# Обработка изображенийданные
image_df = pd.read_csv("Вложение 1/ImageWordData.csv")
image_data = image_df['image_id'].tolist()

# предварительная обработка и загрузка данных
transform = transforms.Compose([
    transforms.Resize((224, 224)),  # Изменение размера изображения по требованию Модельиз
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # Нормализация изображения в соответствии с требованиями Модельиз
])

class ImageEncoder(nn.Module):
    def __init__(self, out_dim=128):
        super(ImageEncoder, self).__init__()
        self.cnn = models.resnet18(pretrained=True)
        self.fc = nn.Linear(512, out_dim)

    def forward(self, x):
        with torch.no_grad():
            x = self.cnn.conv1(x)
            x = self.cnn.bn1(x)
            x = self.cnn.relu(x)
            x = self.cnn.maxpool(x)

            x = self.cnn.layer1(x)
            x = self.cnn.layer2(x)
            x = self.cnn.layer3(x)
            x = self.cnn.layer4(x)

        x = F.adaptive_avg_pool2d(x, (1, 1))
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

class TextEncoder(nn.Module):
    def __init__(self,embedding_dim):
        super(TextEncoder, self).__init__()
        self.rnn = nn.LSTM(embedding_dim, 128, batch_first=True)

    def forward(self, x):
        # x = x.to(device)
        _, (x, __) = self.rnn(x)
        x = x.squeeze(1)
        return x
class MultimodalCnn(nn.Module):
    ...немного
        return fusion
# Определите функцию контрастных потерь
class ContrastiveLoss(nn.Module):
    def __init__(self, margin=2.0):
        super(ContrastiveLoss, self).__init__()
        self.margin = margin

    def forward(self, output1, output2, label):
        euclidean_distance = F.pairwise_distance(output1, output2, keepdim=True)
        loss_contrastive = torch.mean((1-label) * torch.pow(euclidean_distance, 2) +
                                      (label) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2))
        return loss_contrastive
# Определите евклидову функцию потери расстояния
class EuclideanDistanceLoss(nn.Module):
    def __init__(self):
        super(EuclideanDistanceLoss, self).__init__()

    def forward(self, output1, output2, label):
        euclidean_distance = F.pairwise_distance(output1, output2, keepdim=True)
        loss = torch.mean(torch.pow(euclidean_distance - label, 2))
        return loss
class CosineDistanceLoss(nn.Module):
    def __init__(self, margin=0.5):
        super(CosineDistanceLoss, self).__init__()
        self.margin = margin

    def forward(self, output1, output2, label):
        cos_sim = F.cosine_similarity(output1, output2)
        loss = torch.mean((1 - label) * torch.pow(cos_sim, 2) + label * torch.pow(torch.clamp(self.margin - cos_sim, min=0.0), 2))
        return loss

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Вес модели тренировки
image_encoder = ImageEncoder().to(device)
text_encoder = TextEncoder(embedding_dim=300).to(device)
model = MultimodalCnn(image_encoder, text_encoder).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Итеративное обучение Модель
num_epochs = 5
# Создание экземпляра функции контрастных потерь
# criterion = ContrastiveLoss(margin=2.0)
# Евклидова функция потери расстояния
# criterion = EuclideanDistanceLoss()
criterion = CosineDistanceLoss()
for epoch in range(num_epochs):
    running_loss = 0.0
    for i, (image, text) in enumerate(zip(image_data, text_data1)):
        # Загрузить изображение
        image_path = «Вложение 1/ImageData/» + image  # Путь к папке с изображениями
        img = Image.open(image_path)
        if img.mode != 'RGB':
            # Если изображение не в формате RGB, сначала преобразуйте его в формат RGB.
            img = img.convert('RGB')
        img = transform(img).unsqueeze(0).to(device)

        # Загрузить текст
        sentence_vec = [torch.tensor(vocabulary_vector[word], dtype=torch.float) for word in text if word in vocabulary_vector]
        # Вычислите среднее значение каждого вектора сегментации слов в предложении и преобразуйте результат в тензор факела.
        if len(sentence_vec)>0:
            text_sequence = torch.stack(sentence_vec).unsqueeze(0).to(device) 
            optimizer.zero_grad()
            
            # прямое распространение
            ...немного
            # Обратное распространение ошибки и оптимизация
            loss.backward()  # Обратное распространение ошибки
            
            optimizer.step()  # Обновить веса
            
            running_loss += loss.item()
        else:
            # Это не вектор из текста
            print(text)
    # Выведите потери для каждой эпохи
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss / len(image_data)}")
# Сохранить вес модели
torch.save(model.state_dict(), 'models/multimodal_cnn_weights.pth')

# Обработка текстданных
text_df = pd.read_csv("Приложение 2/word_test.csv")
# Определить функцию сегментации китайского слова
def Chinese_tokenizer(text):
    return list(jieba.cut(text))

# Выполните сегментацию китайских слов в заголовке
text_data = text_df['caption'].apply(Chinese_tokenizer).tolist()

# Поскольку загрузка word2vec занимает очень много времени, требуется векторная локализация.
file_path = "word2vec/test_vocabulary_vector.csv"
if os.path.exists(file_path):
    # Чтение словаря - векторный словарь, csv в словарь
    vocabulary_vector = dict(pd.read_csv("word2vec/test_vocabulary_vector.csv"))
    # В это время необходимо восстановить данные типа вектора слов np.array в словаре до исходного типа для дальнейшего использования.
    for key,value in vocabulary_vector.items():
       vocabulary_vector[key] = np.array(value)
    word2vec_model = KeyedVectors.load('hy-tmp/test_bio_word',mmap='r')
else:
    # Прочитайте векторную модель слова на китайском языке (необходимо заранее скачать соответствующий файл Модель вектора слова)
    word2vec_model = KeyedVectors.load_word2vec_format('hy-tmp/word2vec.bz2', binary=False)
    word2vec_model.init_sims(replace=True)
    word2vec_model.save('hy-tmp/bio_word')
    
    # Постройте словарный запас из всего текста,words_cut Это список после сегментации слов, и каждый элемент отделяется пробелами изstr.
    vocabulary = list(set([word for item in text_data for word in item]))
    
    # Создание словарно-векторного словаря
    vocabulary_vector = {}
    for word in vocabulary:
       if word in word2vec_model:
          vocabulary_vector[word] = word2vec_model[word]
    # Храните словарь-векторный словарь. Поскольку файлы json не могут хорошо сохранять пустые векторы слов, используйте CSV для их сохранения.
    pd.DataFrame(vocabulary_vector).to_csv("word2vec/test_vocabulary_vector.csv")
    
# Обработка изображенийданные
image_df = pd.read_csv("Вложение 2/image_data.csv")
image_data = image_df['image_id'].tolist()

# Нагрузка и вес модели
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
image_encoder = ImageEncoder().to(device)
text_encoder = TextEncoder(embedding_dim=300).to(device)
model = MultimodalCnn(image_encoder, text_encoder).to(device)
model.load_state_dict(torch.load('models/multimodal_cnn_weights.pth'))  # Загрузите предварительно подготовленные веса

from collections import defaultdict
d2 = defaultdict(list)
# Сходство магазина
similarity_ranking = []
result_image_id = []
similarity_list = defaultdict(list)
k =1 
# Получение изображения
for text_id,text in zip(text_df['text_id'],text_data):
    print(f'{k}/{len(text_data)}')
    k+=1
    # Загрузить текст
    sentence_vec = [torch.tensor(vocabulary_vector[word], dtype=torch.float) for word in text if word in vocabulary_vector]
    # Вычислите среднее значение каждого вектора сегментации слов в предложении и преобразуйте результат в тензор факела.
    text_sequence = torch.stack(sentence_vec).unsqueeze(0).to(device) 
    text_features = model.text_encoder(text_sequence)
    text_features = text_features.to("cpu").detach().numpy()

    
    for image_id in image_data:
        image_path = е "Приложение 2/ImageData/{image_id}"
        image = Image.open(image_path).convert('RGB')
        image = transform(image).unsqueeze(0).to(device)
        image_features = model.image_encoder(image)
        image_features = image_features.to("cpu").detach().numpy()
        similarity = cosine_similarity(text_features, image_features)
        similarity_list[text_id].append(similarity)

# Выберите топ-5 самых похожих из картинок
result = []
for key, value_list in similarity_list.items():
    sorted_value_list = sorted(value_list, reverse=True)
    top_three_values = sorted_value_list[:5]
    
    for value in top_three_values:
        index = value_list.index(value)
        id_value = image_data[index]
        rank = top_three_values.index(value) + 1
        result.append([key, id_value, rank])
result

# Сохраните результаты в файле result1.csv.
result_df = pd.DataFrame(result, columns=['text_id', 'similarity_ranking', 'result_image_id'])
result_df.to_csv('result1.csv', index=False)

import os
import pandas as pd
from PIL import Image
import torch
import warnings 
warnings.filterwarnings('ignore')

text_test_csv = «Пример данных/вложения 2/word_test.csv»
image_data_csv = «Пример данных/вложения 2/image_data.csv»
image_folder = "Примерные/Приложение 2/ImageData/"
output_csv = "result_data/result1.csv"

# Читать текст и изображенияданные
text_data = pd.read_csv(text_test_csv)
image_data = pd.read_csv(image_data_csv)

# Инициализируйте модель и процессор
model =...немного
processor = ...немного

# Обработка текста и создание функций
text_inputs = processor(text=text_data['caption'].tolist(),padding=True,return_tensors="pt")
with torch.no_grad():
   text_features = model.get_text_features(**text_inputs).cpu()
# Обрабатывайте каждое изображение и генерируйте функции
image_features_list = []
for image_id in image_data['image_id']:
   image_path = os.path.join(image_folder,image_id)
   image = Image.open(image_path)
   image_inputs = processor(images=image,return_tensors="pt")
   with torch.no_grad():
       image_features = model.get_image_features(**image_inputs).cpu()
   image_features_list.append(image_features)

image_features = torch.vstack(image_features_list)  # Объединены в один Тензор

# Нормализованный вектор признаков
image_features = image_features / image_features.norm(dim=1,keepdim=True)
text_features = text_features / text_features.norm(dim=1,keepdim=True)

# Вычислить сходство между текстом и изображением
similarity = text_features @ image_features.T

# Найдите пятерку наиболее похожих на из
result_records = []
for i,sims in enumerate(similarity):
   top_indices = sims.topk(5).indices
   for rank,idx in enumerate(top_indices):
       result_records.append({
           "text_id":text_data.iloc[i]['text_id'],
           "similarity_ranking":rank + 1,
           "result_image_id":image_data.iloc[int(idx)]['image_id']
       })
# Сохранить в файл CSV
result_df = pd.DataFrame(result_records)
result_df.to_csv(output_csv,index=False)
print(f"Получение изображения Заканчивать,Результаты сохранены в {output_csv}").
result_df

import pandas as pd
import os
from PIL import Image
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
import warnings
warnings.filterwarnings('ignore')
font_path = '/Примерданные/SimHei.ttf'
prop = fm.FontProperties(fname=font_path)
# plt.rcParams['font.sans-serif'] = 'Microsoft YaHei'
result1_csv = "result_data/result1.csv"
# Чтение таблицы result_df
result_df = pd.read_csv(result1_csv)

# Чтение данных изображения 2 картинки в папке
image_folder = «Пример данных/Приложение 2/ImageData»
image_paths = [os.path.join(image_folder,f'{row["result_image_id"]}') for _,row in result_df.iterrows()]
images = [Image.open(image_path) for image_path in image_paths]

# Чтение файла word_test.csv из текстовой информации
text_df = pd.read_csv('Пример данных/Приложение 2/word_test.csv')

# Объединить текстовую информацию с таблицей result_df
result_df = result_df.merge(text_df,on='text_id')
fig,axs = plt.subplots(5,2,figsize=(10,20))

for i in range(10):
   row = result_df.iloc[i]
   image = images[i]
   text = row['caption']
   
   ax = axs[i // 2,i % 2]
   ax.imshow(image)
   ax.set_title(f'Similarity Ranking:{row["similarity_ranking"]}\nText:{text}',fontproperties=prop)
   ax.axis('off')
plt.savefig('result_data/result1.png',dpi=300)
plt.show()

import pandas as pd
from PIL import Image
import torch
import warnings 
warnings.filterwarnings('ignore')
# Определение пути к файлу
image_test_csv = "/Примерданные/Приложение 3/image_test.csv"
word_data_csv = "/Примерданные/приложение3/word_data.csv"
image_folder = "/Примерданные/Приложение 3/ImageData/"
output_csv = "result_data/result2.csv"


# Загрузка модели
text_model = ...немного
vision_model = ...немного
processor = ...немного
# Чтение текстовых данных
word_data = pd.read_csv(word_data_csv)
word_data['caption'] = word_data['caption'].astype(str)

# Текст процесса
text_inputs = processor(text=word_data['caption'].tolist(),padding=True,return_tensors="pt",max_length=32,truncation=True).input_ids
# # Вычисление текстовых функций
with torch.no_grad():
text_features = text_model(text_inputs).pooler_output
text_features /= text_features.norm(dim=1,keepdim=True)

# Чтение идентификатора изображения
image_test = pd.read_csv(image_test_csv)

# Список результатов
results = []

# Перебирать каждое изображение
for image_id in image_test['image_id']:
   # Загрузить изображение
   image_path = f"{image_folder}{image_id}"
   image = Image.open(image_path).convert("RGB")

   # Обработка изображений
   vision_inputs = processor(images=image,return_tensors="pt")

   # Рассчитать характеристики изображения
   with torch.no_grad():
       vision_features = vision_model(**vision_inputs).pooler_output
       vision_features /= vision_features.norm(dim=1,keepdim=True)

   # Вычислить косинусное сходство между текстовыми изображениями
   similarities = (vision_features @ text_features.T).squeeze(0)

   # Получите 5 текстов с наибольшим сходством
   top5_indices = similarities.topk(5).indices

   # Хранить результаты
   for rank,index in enumerate(top5_indices):
       results.append({
           "image_id":image_id,
           "similarity_ranking":rank + 1,
           "result_text_id":word_data.iloc[int(index)]['text_id']
       })
print("Извлечение завершено")

result_df = pd.DataFrame(results)
# Сохраните результаты в CSV документ
result_df = pd.DataFrame(results)
result_df.to_csv(output_csv,index=False)

print("Результаты сохранены",output_csv)
result_df

import pandas as pd
import os
import matplotlib.pyplot as plt
from PIL import Image
import matplotlib.font_manager as fm
import cv2
font_path = '/Примерданные/SimHei.ttf'
prop = fm.FontProperties(fname=font_path)

result2_csv = "result2.csv"
word_data_csv = "/Примерданные/приложение3/word_data.csv"
image_folder = "/Примерданные/Приложение 3/ImageData/"
# Чтение таблицы result_df
result_df = pd.read_csv(result2_csv)

# Прочитать документ word_data.csv
word_data_df = pd.read_csv(word_data_csv)


# Предварительная обработка данных, обработка только первых 20 строк данных.
result_df = result_df.head(20)

# Установить размер артборда
plt.figure(figsize=(10,25))

# Пройдите первые 20 строк данных
for i in range(0,20,5):
    # Получите путь к изображению и соответствующий text_id.
    image_path = os.path.join(image_folder,result_df.iloc[i]["image_id"])
    text_ids = result_df.iloc[i:i+5]['result_text_id']
    
    # Читать картинки
    image = Image.open(image_path)
    
    # Создайте подграф (картинка слева, текст справа)
    plt.subplot(5,1,(i//5) + 1)
    
    # Показать изображение
    plt.imshow(image)
    plt.axis('off')  # Не показывать оси
    
    # Отобразить соответствующий текст
    for j, text_id in enumerate(text_ids):
        # Получить текстовый контент
        caption = word_data.loc[word_data['text_id'] == text_id, 'caption'].values[0]
        # Добавьте текст справа от изображения
        plt.text(image.width + 10, image.height/ 6 * j, caption, va='top',fontproperties=prop)

# Отрегулируйте расстояние между фрагментами изображений
plt.tight_layout()
# Показать весь артборд
plt.show()