我将把所有的功能整合到一个Python文件中，并提供完整的项目结构。这个文件将包含模型训练、图像生成和图形用户界面的功能。以下是完整的项目结构和代码：

项目目录结构
code
text_to_image/
├── config.yaml
├── data/
│ └── sample_text.txt
├── models/
│ └── pretrained_model.pth
├── text_to_image.py
├── requirements.txt
└── README.md
1.
config.yaml
(配置文件)

# config.yaml
model:
  name: "pretrained_model"
  path: "./models/pretrained_model.pth"
data:
  input_file: "./data/sample_text.txt"
  output_dir: "./output/"
training:
  batch_size: 8
  epochs: 10
  learning_rate: 0.001

data/sample_text.txt
(样本文本文件)

美丽的日落海景。
坐在窗台上的猫。
夜晚的城市天际线，灯光璀璨。

models/pretrained_model.pth
(预训练模型权重文件)
这个文件通常是通过训练得到的，这里假设你还没有训练出模型权重文件。
4.
text_to_image.py
(主程序文件)

import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image, ImageTk
import torch
import torch.optim as optim
import torch.nn as nn
import torchvision.transforms as transforms
import yaml
import os

# 配置文件加载
def load_config(config_path):
    with open(config_path, 'r', encoding='utf-8') as file:
        config = yaml.safe_load(file)
    return config

# 数据加载
def load_text_data(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        text_data = file.readlines()
    return [line.strip() for line in text_data]

# 模型定义
class TextToImageModel(nn.Module):
    def __init__(self):
        super(TextToImageModel, self).__init__()
        self.encoder = nn.Linear(100, 512)  # Example encoder
        self.decoder = nn.ConvTranspose2d(512, 3, kernel_size=4, stride=2, padding=1)  # Example decoder

    def forward(self, x):
        x = self.encoder(x)
        x = x.view(-1, 512, 1, 1)
        x = self.decoder(x)
        return x

# 模型加载
def load_model(model_path):
    model = TextToImageModel()
    if os.path.exists(model_path):
        model.load_state_dict(torch.load(model_path))
    model.eval()
    return model

# 图像保存
def save_image(image, path):
    if not os.path.exists(os.path.dirname(path)):
        os.makedirs(os.path.dirname(path))
    image.save(path)

# 模型训练
def train_model(config):
    model = TextToImageModel()
    optimizer = optim.Adam(model.parameters(), lr=config['training']['learning_rate'])
    criterion = nn.MSELoss()

    # 假设这里有训练数据
    # 例如：train_data = ...

    for epoch in range(config['training']['epochs']):
        # 训练循环
        # 例如：for batch in train_data:
        #     optimizer.zero_grad()
        #     outputs = model(batch['input'])
        #     loss = criterion(outputs, batch['target'])
        #     loss.backward()
        #     optimizer.step()

        print(f"Epoch {epoch + 1} completed.")

    # 保存训练好的模型
    torch.save(model.state_dict(), config['model']['path'])

# 图像生成
def generate_images(model, text_data, output_dir):
    for text in text_data:
        # 假设这里有一个函数将文本转换为模型输入
        input_tensor = torch.randn(1, 100)  # 示例输入
        image = model(input_tensor)
        image = image.squeeze(0).detach().cpu().numpy()
        image = (image * 255).astype('uint8')
        image = Image.fromarray(image.transpose(1, 2, 0))

        # 保存图像
        save_image(image, f"{output_dir}/{text}.png")

# 图形用户界面
class TextToImageGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("文本生成图像")
        self.config = load_config('config.yaml')
        self.model = load_model(self.config['model']['path'])

        self.text_input = tk.Text(root, height=10, width=50)
        self.text_input.pack(pady=10)

        self.generate_button = tk.Button(root, text="生成图像", command=self.generate_image)
        self.generate_button.pack(pady=10)

        self.image_label = tk.Label(root)
        self.image_label.pack(pady=10)

    def generate_image(self):
        text = self.text_input.get("1.0", tk.END).strip()
        if not text:
            messagebox.showwarning("警告", "请输入文本")
            return

        # 假设这里有一个函数将文本转换为模型输入
        input_tensor = torch.randn(1, 100)  # 示例输入
        image = self.model(input_tensor)
        image = image.squeeze(0).detach().cpu().numpy()
        image = (image * 255).astype('uint8')
        image = Image.fromarray(image.transpose(1, 2, 0))

        # 显示图像
        img_tk = ImageTk.PhotoImage(image)
        self.image_label.config(image=img_tk)
        self.image_label.image = img_tk

        # 保存图像
        save_image(image, f"{self.config['data']['output_dir']}/{text}.png")
        messagebox.showinfo("成功", "图像已生成并保存")

if __name__ == "__main__":
    config = load_config('config.yaml')

    # 训练模型
    train_model(config)

    # 加载模型
    model = load_model(config['model']['path'])

    # 加载文本数据
    text_data = load_text_data(config['data']['input_file'])

    # 生成图像
    generate_images(model, text_data, config['data']['output_dir'])

    # 启动图形用户界面
    root = tk.Tk()
    app = TextToImageGUI(root)
    root.mainloop()