【AI绘画】Midjourney前置指令/imagine与单图指令详解

博客主页：[小ᶻ☡꙳ᵃⁱᵍᶜ꙳] 本文专栏: AI绘画|Midjourney

文章目录

💯Midjourney前置指令/imagine
💯单张图片指令
- Upscale (分辨率*2并调整细节)
- Vary（变体）
- [Zoom out（放大）](#Zoom out（放大）)
- [Custom Zoom（自定义放大）](#Custom Zoom（自定义放大）)
- ⬅➡⬆⬇（单向扩张）
- ❤（喜欢）
- web分享
💯小结

💯Midjourney前置指令/imagine

在Midjourney的使用过程中，前置指令/image是非常重要的工具，帮助用户在Discord平台上有效地生成图像。通过/imagine指令，用户可以在聊天界面中输入描述性文本，Midjourney便会根据这些描述生成对应的图像。这种方式让用户无需通过复杂的界面操作，而是通过简单的文本输入，即可调用Midjourney的强大功能，生成高质量的视觉内容。
Midjourney官方使用手册

什么是前置指令？

在使用Midjourney时，有一个重要的概念叫做"前置指令"。用来描述那些用于调用Midjourney不同功能的特殊命令。
Midjourney与其他图像生成软件不同之处在于，它并不是一个传统意义上的专业功能软件。

比如，你打开Photoshop，会看到界面上有各种按钮，每个按钮对应一个具体的功能，非常直观。
Photoshop界面:
或者你使用Stable Diffusion，它会有一个专门的页面，我们可以调整各自参数来生成图片。
Stable Diffusion界面:
然而，Midjourney的独特之处在于它嵌入在Discord的聊天界面中,相当于是一个内置于用户创建的服务器中的机器人。为了使用这个机器人的功能，你需要通过输入一些特定的命令或聊天内容来调用，而不是直接通过图形界面的按钮操作。
Midjourney相当于服务器中的机器人：
如果你在聊天界面中直接输入生成图片的指令，它只会被视为普通的聊天内容，并不会触发Midjourney的图像生成功能。
没有加上前置指令：
为了让Midjourney理解并执行生成图像的命令，必须使用特定的格式，这种格式就是所谓的"前置指令"。
加上前置指令后：

前置指令是什么样的呢？首先我们要在聊天框一开始加上一个斜杠"/"，这一步是为了告诉Midjourney的服务器，你不是在进行普通的聊天，而是希望调用Midjourney机器人的某项功能。当你输入斜杠后，Midjourney Bot会启动并询问你需要它执行什么任务。在这一系列命令中，最常用的就是/imagine，它用于生成图像，这就是本文重点要介绍的内容。

/imagine+prompt

当你选择了/imagine命令后，接下来会出现一个提示词输入框，即prompt提示。在这里，你需要用英文输入你希望Midjourney生成图片的画面描述。这个描述越具体、越清晰，Midjourney生成的图像就会越接近你的预期。
在创建提示词时，我们可以先用中文整理好我们想要的表达，然后再借助翻译软件将其转换成英文，以确保描述准确并符合我们的预期。
以下作为本文的Prompt例子：

Elegant and luxurious glass perfume bottle with a sleek design, filled with a soft pink liquid. The bottle features a gold-plated cap with intricate engravings, set against a marble surface with subtle reflections. Delicate rose petals and dewdrops are scattered around the bottle, with soft, diffused lighting creating a warm and inviting atmosphere. The background fades into a smooth gradient of pastel tones, emphasizing the premium and sophisticated nature of the perfume. Perfect for a high-end fragrance advertisement.
通过这种方式，我们成功调用了/imagine命令，并以/imagine + prompt的形式向Midjourney传达了我们的需求，最终生成了一张香水静物图。
接下来本文将介绍生成图片下的按钮具体有什么功能：

Upscale（图像分离）

U按钮代表"Upscale"图像分离功能。U1、U2、U3、U4分别对应第一、第二、第三、第四张生成的图像，选择其中一个按钮即可将对应的图像进行将您选择的图像从网格中分离出来放大单独呈现，使其更加细腻和清晰。

Variations（变化）

V (Variations)：表示基于生成的图像创建更多的变体。按钮后面的数字（1、2、3、4）对应四张生成的图像。选择某个V按钮（如V1），即要求Midjourney基于第一张图像生成几个不同的变体图像。
这里的变化程度可通过/setting中进行调整，在之前的【AI绘画】Midjourney前置指令/settings设置详解介绍过了。

🔄（重新生成一组图片）

这个按钮用于重新生成一组全新的图像，基于你原先输入的提示词（prompt）。如果对初次生成的图像不满意，点击这个按钮可以让Midjourney根据你在原提示词的基础上提交的新提示词生成一组新的图像。
这个功能非常有用，尤其是在你想要在一张图上探索更多不同的视觉效果时。

💯单张图片指令

这里的单图指的是在一组四图情况下由U指令生成的单张图片。
在使用U指令生成单张图片后，我们发现这张图片下方的按钮与原先一组四张图片时的按钮有所不同。单图下的按钮提供了更多针对单一图像的操作选项。接下来我们将介绍这些按钮的具体功能。

Upscale (分辨率*2并调整细节)

在单张图片下的Upscale按钮后面，你会看到有两种选项：Subtle 和 Creative。这与之前在一组四张图像中讨论到的U按钮有所不同。

之前在四张图片的情境下，U按钮主要用于将选中的图像进行分离放大操作，使其更加清晰。而在单图情况下的Upscale按钮，在分辨率*2的基础上，主要是用来细节优化，还提供了两种不同的优化方式。
Upscale (Subtle)：这个按钮用于对图片进行细微的优化处理。在分辨率*2的基础上，它会保留图片的原始风格和细节，仅仅对图像进行增强清晰度和精致度，而不会对原有的视觉效果做出明显的改变。这个选项适合当你对生成图像的整体满意，但希望它在更高分辨率下依然保持细腻感时使用。
Upscale (Creative)：这个按钮则提供了一种更具创意的细节优化方式。在分辨率*2的基础上，它会对图像进行一些创造性的调整，可能会增强颜色、细节或者添加一些新的元素。这个选项适合想要在现有图像基础上增加一点变化或探索不同风格的用户使用。
变化真的有点不太明显，不仔细看好像还真长的一样哈哈哈

2024.8.30补充：

之前的例子没有很好的体现图片分辨率放大的效果，以下是验证：

这是原图
这是Upscale (Creative)下生成的图片：
虽然这两张图看着是一样大的，但是当我们将这两张图用浏览器打开，保存到本地后我们可以发现：Upscale (Creative)图片28%和原图56%一样大，这就侧面说明了Upscale (Creative)生成的图片分辨率是原图的两倍，所以Upscale (Creative)模式下会使图片分辨率增大为原来的2倍，这直接看很难看出来，要通过下载图片才可以方便看。

Vary（变体）

一个叫做剧烈的变化，一个叫做轻微的变化，还有一个是特定区域进行变化。

它这个作用就是在这个界面再次的去生成四张图片，又回到了我们上一个一组四图的层级。只不过第一个在强壮的这么一个选项下，我们生成出来的这个图片，它和原来图片变化就是比较大的。虽然保留了原来的色调和构图，但是它已经产生了非常剧烈的形状的变化。但是这个轻微的这个里面它图片的变化要小很多。特定变化是选择图像中的某个部分，然后Midjourney会基于这个区域生成变体，而不改变图像的其他部分。
Vary (Strong)：选择这个选项时，Midjourney会基于你原始图像生成四张新的图片。这些图片虽然保留了原来的色调和构图，但会在形状和其他细节上发生显著变化。这个选项适用于希望在原始图像的基础上探索更大幅度的创意变化时使用。
Vary (Subtle)：与剧烈变化不同，轻微变化选项生成的图像与原始图像的差异较小。虽然会有一些细节上的调整，但整体风格和结构基本保持不变。这适合希望在现有基础上做出微调而不改变整体效果时使用。
Vary (Region)：允许用户对图像中的特定区域进行变动。例如，如果你对图像中的某个元素或细节不满意，可以使用Vary (Region) 选择该区域，然后Midjourney会生成这个区域的多种变体。这个功能非常适合需要对图像进行局部调整的情况，比如你想改变背景的颜色、调整一个对象的位置或者修改某些细节，而不影响图像的整体构图和风格。

这里我将三片花瓣作为变化区域，想将花瓣变成蓝色。

Zoom out（放大）

这三个按钮的作用都是在原来图片的基础上，在周围进行放大。

Zoom Out 按钮用于扩大视野范围并显示更多的背景或环境，对图像本体进行缩小处理。这个功能在你希望通过扩大视角来展示更多细节或将图像的焦点从局部扩展到整体时非常有用。
Zoom Out 2x：将图像的视野扩大为原始大小的两倍。这个选项会显示出更大的背景区域，让图像中的主体显得较小，同时展示出更多的周围环境。
Zoom Out 1.5x：将图像的视野扩大为原始大小的1.5倍。这个选项与Zoom Out 2x相比，效果较为温和，主体依然相对突出，但同时能够展示更多的背景内容。

Custom Zoom（自定义放大）

Costume是自定义的意思，Zoom是放大的意思，组合在一起是自定义放大。同时我们可以自定义放大填充的内容。

Custom Zoom：这个选项允许你手动设置缩放比例（1-2之间），从而灵活地调整图像的放大程度。同时，Custom Zoom还提供了一个独特的功能，即你可以自定义填充放大后空白区域的内容。这样，你不仅能够控制图像的视角和焦点，还能决定放大后新增区域的具体内容，从而更精确地实现你的创作意图。
为了测试该功能我们换一个人像的提示词

Portrait of a Chinese antique girl,photo,close-up,beautiful,elegant,realistic,8k,extreme details,movie visuals,ambient light
Midjourney根据我们的提示词进行绘画
在提示词中输入填充部分的内容，zoom后面加放大的倍数（1-2之间）
实现了相框包裹效果

⬅➡⬆⬇（单向扩张）

这四个按钮就是zoom out的微缩版，只能一个方向进行扩张。

单方向扩张功能按钮，是对图像进行方向性的扩展。这些按钮分别对应向左、向右、向上或向下扩展图像的视野范围。
向上扩展
向下扩展
向左扩展
向右扩展

❤（喜欢）

这个按钮让你标记你特别喜欢的图像。当你点击这个按钮后，Midjourney会记录你对这张图像的偏好，可能会用来影响日后生成的图像风格。标记为"喜欢"的图像还可以帮助你快速找到你最满意的作品。

web分享

点击这个按钮会生成一个链接，允许你在网络上分享这张图像。链接会指向一个网页，其他人可以通过这个链接查看你生成的图像。这个功能非常方便你与他人分享你的创作成果，或将图像展示在社交媒体上。

💯小结

AI绘画的发展，不仅使艺术创作变得更加大众化，让更多的人能够接触并使用这些前沿的技术进行创作；更重要的是，它激发了人们对创意表达的无限可能性。Midjourney的各种功能，例如Upscale、Variations、Custom Zoom等，不仅体现了AI技术的进步，也展现了技术与艺术融合所带来的无限可能。这些工具不仅仅是为了提升图像的质量，更是在探索艺术表达的新方式，使得创作者可以更自由、更大胆地尝试不同的创作风格和形式。
随着AI绘画技术的不断发展，未来我们将看到更多类似Midjourney这样的工具，它们将继续推动艺术创作的发展，让艺术家和普通用户都能在数字化创作的世界中找到属于自己的表达方式。

python 复制代码

import torch, torch.nn as nn, torch.optim as optim; from torch.utils.data import Dataset, DataLoader; from torchvision import transforms, utils; from PIL import Image; import numpy as np, cv2, os, random; class PaintingDataset(Dataset): def __init__(self, root_dir, transform=None): self.root_dir = root_dir; self.transform = transform; self.image_files = os.listdir(root_dir); def __len__(self): return len(self.image_files); def __getitem__(self, idx): img_name = os.path.join(self.root_dir, self.image_files[idx]); image = Image.open(img_name).convert('RGB'); if self.transform: image = self.transform(image); return image; class ResidualBlock(nn.Module): def __init__(self, in_channels): super(ResidualBlock, self).__init__(); self.conv_block = nn.Sequential(nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1), nn.InstanceNorm2d(in_channels), nn.ReLU(inplace=True), nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1), nn.InstanceNorm2d(in_channels)); def forward(self, x): return x + self.conv_block(x); class Generator(nn.Module): def __init__(self): super(Generator, self).__init__(); self.downsampling = nn.Sequential(nn.Conv2d(3, 64, kernel_size=7, stride=1, padding=3), nn.InstanceNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1), nn.InstanceNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1), nn.InstanceNorm2d(256), nn.ReLU(inplace=True)); self.residuals = nn.Sequential(*[ResidualBlock(256) for _ in range(9)]); self.upsampling = nn.Sequential(nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1), nn.InstanceNorm2d(128), nn.ReLU(inplace=True), nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, output_padding=1), nn.InstanceNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(64, 3, kernel_size=7, stride=1, padding=3), nn.Tanh()); def forward(self, x): x = self.downsampling(x); x = self.residuals(x); x = self.upsampling(x); return x; class Discriminator(nn.Module): def __init__(self): super(Discriminator, self).__init__(); self.model = nn.Sequential(nn.Conv2d(3, 64, kernel_size=4, stride=2, padding=1), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1), nn.InstanceNorm2d(128), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1), nn.InstanceNorm2d(256), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1), nn.InstanceNorm2d(512), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(512, 1, kernel_size=4, stride=1, padding=1)); def forward(self, x): return self.model(x); def initialize_weights(model): for m in model.modules(): if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)): nn.init.normal_(m.weight.data, 0.0, 0.02); elif isinstance(m, nn.InstanceNorm2d): nn.init.normal_(m.weight.data, 1.0, 0.02); nn.init.constant_(m.bias.data, 0); device = torch.device("cuda" if torch.cuda.is_available() else "cpu"); generator = Generator().to(device); discriminator = Discriminator().to(device); initialize_weights(generator); initialize_weights(discriminator); transform = transforms.Compose([transforms.Resize(256), transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])]); dataset = PaintingDataset(root_dir='path_to_paintings', transform=transform); dataloader = DataLoader(dataset, batch_size=16, shuffle=True); criterion = nn.MSELoss(); optimizerG = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999)); optimizerD = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999)); def generate_noise_image(height, width): return torch.randn(1, 3, height, width, device=device); for epoch in range(100): for i, data in enumerate(dataloader): real_images = data.to(device); batch_size = real_images.size(0); optimizerD.zero_grad(); noise_image = generate_noise_image(256, 256); fake_images = generator(noise_image); real_labels = torch.ones(batch_size, 1, 16, 16, device=device); fake_labels = torch.zeros(batch_size, 1, 16, 16, device=device); output_real = discriminator(real_images); output_fake = discriminator(fake_images.detach()); loss_real = criterion(output_real, real_labels); loss_fake = criterion(output_fake, fake_labels); lossD = (loss_real + loss_fake) / 2; lossD.backward(); optimizerD.step(); optimizerG.zero_grad(); output_fake = discriminator(fake_images); lossG = criterion(output_fake, real_labels); lossG.backward(); optimizerG.step(); with torch.no_grad(): fake_image = generator(generate_noise_image(256, 256)).detach().cpu(); grid = utils.make_grid(fake_image, normalize=True); utils.save_image(grid, f'output/fake_painting_epoch_{epoch}.png'); def apply_style_transfer(content_img, style_img, output_img, num_steps=500, style_weight=1000000, content_weight=1): vgg = models.vgg19(pretrained=True).features.to(device).eval(); for param in vgg.parameters(): param.requires_grad = False; content_img = Image.open(content_img).convert('RGB'); style_img = Image.open(style_img).convert('RGB'); content_img = transform(content_img).unsqueeze(0).to(device); style_img = transform(style_img).unsqueeze(0).to(device); target = content_img.clone().requires_grad_(True).to(device); optimizer = optim.LBFGS([target]); content_layers = ['conv_4']; style_layers = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']; def get_features(image, model): layers = {'0': 'conv_1', '5': 'conv_2', '10': 'conv_3', '19': 'conv_4', '28': 'conv_5'}; features = {}; x = image; for name, layer in model._modules.items(): x = layer(x); if name in layers: features[layers[name]] = x; return features; def gram_matrix(tensor): _, d, h, w = tensor.size(); tensor = tensor.view(d, h * w); gram = torch.mm(tensor, tensor.t()); return gram; content_features = get_features(content_img, vgg); style_features = get_features(style_img, vgg); style_grams = {layer: gram_matrix(style_features[layer]) for layer in style_features}; for step in range(num_steps): def closure(): target_features = get_features(target, vgg); content_loss = torch.mean((target_features[content_layers[0]] - content_features[content_layers[0]])**2); style_loss = 0; for layer in style_layers: target_gram = gram_matrix(target_features[layer]); style_gram = style_grams[layer]; layer_style_loss = torch.mean((target_gram - style_gram)**2); style_loss += layer_style_loss / (target_gram.shape[1] ** 2); total_loss = content_weight * content_loss + style_weight * style_loss; optimizer.zero_grad(); total_loss.backward(); return total_loss; optimizer.step(closure); target = target.squeeze().cpu().clamp_(0, 1); utils.save_image(target, output_img);