讓大模型幫我設計crnn網絡及可運行demo，gpt4o豆包qwendeepseek-r1

prompt

使用 crnn 提取圖像特征，給出圖像好壞的二分類結果，寫清楚代碼備注，注釋清楚向量維度大小，并給出一個可運行的 demo

1、GPT-4o

以下是一個使用 CRNN（Convolutional Recurrent Neural Network）提取圖像特征并進行二分類的完整代碼示例。我們將使用 PyTorch 框架來實現。代碼中會包含詳細的注釋，解釋每一步的操作和向量維度變化。

1. 安裝依賴

首先，確保你已經安裝了 PyTorch 和 torchvision。如果沒有安裝，可以使用以下命令安裝：

pip install torch torchvision

2. 代碼實現

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms, datasets
import numpy as np
import matplotlib.pyplot as plt# 設置隨機種子，確保結果可復現
torch.manual_seed(42)# 定義一個簡單的自定義數據集（用于演示）
class SimpleImageDataset(Dataset):def __init__(self, num_samples=1000, img_size=(32, 32)):self.num_samples = num_samplesself.img_size = img_sizeself.data = []self.labels = []# 生成隨機圖像數據for _ in range(num_samples):# 隨機生成圖像（0-1之間的浮點數）img = np.random.rand(*img_size).astype(np.float32)# 隨機生成標簽（0 或 1）label = np.random.randint(0, 2)self.data.append(img)self.labels.append(label)def __len__(self):return self.num_samplesdef __getitem__(self, idx):# 返回圖像和標簽img = self.data[idx]label = self.labels[idx]# 將圖像轉換為 PyTorch 張量，并添加通道維度 (1, H, W)img = torch.tensor(img).unsqueeze(0)  # (1, H, W)label = torch.tensor(label).long()  # 標簽為整數return img, label# 定義 CRNN 模型
class CRNN(nn.Module):def __init__(self, input_channels=1, num_classes=2):super(CRNN, self).__init__()# 卷積層self.conv = nn.Sequential(nn.Conv2d(input_channels, 16, kernel_size=3, stride=1, padding=1),  # (B, 16, H, W)nn.ReLU(),nn.MaxPool2d(2, 2),  # (B, 16, H/2, W/2)nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),  # (B, 32, H/2, W/2)nn.ReLU(),nn.MaxPool2d(2, 2)  # (B, 32, H/4, W/4))# RNN 層self.rnn_input_size = 32 * (img_size[1] // 4)  # RNN 輸入大小 = 通道數 * 寬度self.rnn = nn.LSTM(self.rnn_input_size, 128, batch_first=True, bidirectional=True)  # 雙向 LSTM# 全連接層self.fc = nn.Linear(128 * 2, num_classes)  # 雙向 LSTM 輸出大小為 128 * 2def forward(self, x):# 輸入 x 的形狀: (B, C, H, W)batch_size = x.size(0)# 卷積層x = self.conv(x)  # (B, 32, H/4, W/4)# 調整形狀以適配 RNN 輸入x = x.permute(0, 2, 3, 1)  # (B, H/4, W/4, 32)x = x.view(batch_size, -1, self.rnn_input_size)  # (B, H/4, 32 * W/4)# RNN 層x, _ = self.rnn(x)  # (B, H/4, 128 * 2)# 取最后一個時間步的輸出x = x[:, -1, :]  # (B, 128 * 2)# 全連接層x = self.fc(x)  # (B, num_classes)return x# 設置超參數
img_size = (32, 32)  # 圖像大小
batch_size = 16
num_epochs = 5
learning_rate = 0.001# 創建數據集和數據加載器
dataset = SimpleImageDataset(num_samples=1000, img_size=img_size)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)# 初始化模型、損失函數和優化器
model = CRNN(input_channels=1, num_classes=2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)# 訓練模型
for epoch in range(num_epochs):model.train()total_loss = 0for images, labels in dataloader:# 前向傳播outputs = model(images)loss = criterion(outputs, labels)# 反向傳播和優化optimizer.zero_grad()loss.backward()optimizer.step()total_loss += loss.item()print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {total_loss/len(dataloader):.4f}")# 測試模型
model.eval()
with torch.no_grad():# 從數據集中取一個樣本進行測試test_img, test_label = dataset[0]test_img = test_img.unsqueeze(0)  # 添加 batch 維度 (1, 1, H, W)output = model(test_img)predicted_label = torch.argmax(output, dim=1).item()print(f"True Label: {test_label}, Predicted Label: {predicted_label}")# 可視化測試圖像plt.imshow(test_img.squeeze(0).squeeze(0), cmap="gray")plt.title(f"Predicted: {predicted_label}, True: {test_label}")plt.show()

3. 代碼說明

  1. 數據集:

    • 使用了一個簡單的自定義數據集 SimpleImageDataset，生成隨機圖像和二分類標簽。
    • 圖像大小為 (32, 32)，標簽為 0 或 1。

  2. CRNN 模型:

    • 卷積層提取圖像的空間特征。
    • RNN 層（LSTM）處理序列特征，輸入為卷積層輸出的特征序列。
    • 全連接層將 RNN 的輸出映射到二分類結果。

  3. 訓練:

    • 使用交叉熵損失函數 CrossEntropyLoss。
    • 優化器為 Adam。

  4. 測試:

    • 從數據集中取一個樣本，使用訓練好的模型進行預測，并可視化結果。

4. 運行結果

運行代碼后，你會看到訓練過程中的損失值，以及測試樣本的預測結果和真實標簽。測試圖像會以灰度圖形式顯示。

如果你有任何問題或需要進一步的幫助，請隨時告訴我！ 😊

2、豆包-1.5pro

下面是一個基于PyTorch框架實現的使用CRNN（Convolutional Recurrent Neural Network）進行圖像二分類的示例代碼。這個示例假設輸入圖像為正方形且為灰度圖。對于彩色圖像，可以簡單修改卷積層以便處理3通道數據。

1. 引入必要的庫

import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader
import torch.optim as optim
from PIL import Image# 用于圖像預處理
transform = transforms.Compose([transforms.Resize((32, 32)),transforms.Grayscale(),transforms.ToTensor(),# 將圖像數據標準化到[-1, 1]transforms.Normalize((0.5,), (0.5,))
])

2. 定義CRNN模型

class CRNN(nn.Module):def __init__(self):super(CRNN, self).__init__()# 卷積層1，輸入通道數1（灰度圖），輸出通道數16，卷積核大小3x3，步長1，填充1self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)self.relu1 = nn.ReLU()# 最大池化層1，窗口大小2x2，步長2self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)# 卷積層2，輸入通道數16，輸出通道數32，卷積核大小3x3，步長1，填充1self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)self.relu2 = nn.ReLU()# 最大池化層2，窗口大小2x2，步長2self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)# 展平層，將多維張量展平為一維self.flatten = nn.Flatten()# RNN層，這里使用GRU，輸入特征維度32 * 8 * 8 ，隱藏層維度64，1層self.gru = nn.GRU(input_size=32 * 8 * 8, hidden_size=64, num_layers=1, batch_first=True)# 全連接層，將GRU輸出的64維向量映射到2維（2個類別）self.fc = nn.Linear(64, 2)def forward(self, x):x = self.pool1(self.relu1(self.conv1(x)))x = self.pool2(self.relu2(self.conv2(x)))x = self.flatten(x)x = x.unsqueeze(1)x, _ = self.gru(x)# 只取GRU最后一個時刻的輸出x = x[:, -1, :]x = self.fc(x)return x

3. 定義訓練過程

# 創建數據加載器，假設數據按類別存放在data/train目錄下
train_dataset = ImageFolder(root='data/train', transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)# 創建模型實例
model = CRNN()# 定義損失函數和優化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)# 訓練模型
num_epochs = 10
for epoch in range(num_epochs):running_loss = 0.0correct = 0total = 0for i, data in enumerate(train_loader, 0):inputs, labels = dataoptimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()print(f'Epoch {epoch + 1}, Loss: {running_loss / len(train_loader)}, 'f'Accuracy: {correct / total * 100}%')

4. 定義預測過程

# 創建測試集數據加載器，假設數據按類別存放在data/test目錄下
test_dataset = ImageFolder(root='data/test', transform=transform)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)# 評估模型
correct = 0
total = 0
with torch.no_grad():for data in test_loader:images, labels = dataoutputs = model(images)_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()print(f'Accuracy of the network on the test images: {correct / total * 100}%')def predict_single_image(image_path, model):img = Image.open(image_path).convert('L')img = transform(img).unsqueeze(0)with torch.no_grad():output = model(img)_, predicted = torch.max(output.data, 1)return predicted.item()

5. 運行預測

# 預測單個圖像，這里假設image.jpg是需要預測的圖像
predicted_class = predict_single_image('image.jpg', model)
print(f'Predicted class for single image: {predicted_class}')

代碼說明

  1. 圖像預處理：使用transforms.Compose將圖像調整大小為32x32，轉換為灰度圖，然后轉換為張量并進行標準化。
  2. CRNN模型：
    • 卷積層部分：使用了兩個Conv2d層和對應的ReLU激活函數以及MaxPool2d池化層進行特征提取。Conv2d層用于學習圖像的局部特征，池化層用于降低數據維度。
    • RNN層部分：將卷積層輸出的數據展平后輸入到GRU層，學習序列特征（此處將圖像數據看成一個序列）。
    • 全連接層：將GRU層的輸出映射到2個類別，輸出最終的分類結果。
  3. 訓練過程：
    • 加載訓練數據集，使用ImageFolder和DataLoader按批次加載數據。
    • 定義損失函數（CrossEntropyLoss）和優化器（Adam）。
    • 在每個epoch中，前向傳播計算損失，反向傳播更新模型參數，并打印每個epoch的損失和準確率。
  4. 預測過程：
    • 加載測試數據集，對測試集進行評估并打印準確率。
    • predict_single_image函數用于對單個圖像進行預測，返回預測的類別。

請確保安裝了torch、torchvision和Pillow庫，可以使用以下命令安裝：

pip install torch torchvision pillow

測試和訓練數據集的目錄結構應如下：

data/
├── train/
│   ├── good_images/
│   │   ├── image1.jpg
│   │   ├── image2.jpg
│   │   └──...
│   └── bad_images/
│       ├── image3.jpg
│       ├── image4.jpg
│       └──...
└── test/├── good_images/│   ├── image5.jpg│   ├── image6.jpg│   └──...└── bad_images/├── image7.jpg├── image8.jpg└──...

在實際應用中，你可以根據具體的數據集和任務需求調整模型架構、超參數等。

3、Qwen-2.5

好的，下面是一個使用CRNN（卷積循環神經網絡）提取圖像特征并用于二分類任務的PyTorch示例代碼。我們將使用一個簡單的CRNN模型來實現這個任務。代碼中會包含詳細的注釋說明每一步的操作和向量維度的變化。

首先，確保你已經安裝了必要的庫：

pip install torch torchvision

以下是完整的代碼示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets
from torch.utils.data import DataLoader# 定義CRNN模型
class CRNN(nn.Module):def __init__(self, num_classes=2, input_size=1024, hidden_size=512, num_layers=2):super(CRNN, self).__0__init__()self.num_classes = num_classesself.hidden_size = hidden_sizeself.num_layers = num_layers# 卷積層self.conv = nn.Sequential(nn.Conv2d(3, 64, kernel_size=(3, 3), padding=(1, 1)),nn.ReLU(),nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2)),  # (B, 64, H/2, W/2)nn.Conv2d(64, 128, kernel_size=(3, 3), padding=(1, 1)),nn.ReLU(),nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2)),  # (B, 128, H/4, W/4)nn.Conv2d(128, 256, kernel_size=(3, 3), padding=(1, 1)),nn.ReLU(),nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2)),  # (B, 256, H/8, W/8)nn.Conv2d(256, 512, kernel_size=(3, 3), padding=(1, 1)),nn.ReLU(),nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))   # (B, 512, H/16, W/16))# 計算經過卷積層后的輸出尺寸self.fc_input_size = 512 * (32 // 16) * (32 // 16)  # 假設輸入圖像大小為 (B, 3, 32, 32)# 全連接層self.fc = nn.Linear(self.fc_input_size, input_size)# 循環層self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)# 輸出層self.fc_out = nn.Linear(hidden_size, num_classes)def forward(self, x):# 卷積層conv_out = self.conv(x)  # (B, 512, H/16, W/16)batch_size, channels, height, width = conv_out.size()# 展平conv_out = conv_out.view(batch_size, channels * height, width)  # (B, 512*(H/16), W/16)# 全連接層conv_out = conv_out.permute(0, 2, 1)  # (B, W/16, 512*(H/16))fc_out = self.fc(conv_out)  # (B, W/16, input_size)# 循環層out, _ = self.lstm(fc_out)  # (B, W/16, hidden_size)# 取最后一個時間步的輸出out = out[:, -1, :]  # (B, hidden_size)# 輸出層out = self.fc_out(out)  # (B, num_classes)return out# 數據預處理
transform = transforms.Compose([transforms.Resize((32, 32)),transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])# 加載數據集
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)# 初始化模型、損失函數和優化器
model = CRNN(num_classes=2, input_size=1024, hidden_size=512, num_layers=2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)# 訓練模型
num_epochs = 10
for epoch in range(num_epochs):model.train()for i, (images, labels) in enumerate(train_loader):optimizer.zero_grad()outputs = model(images)loss = criterion(outputs, labels)loss.backward()optimizer.step()if (i + 1) % 100 == 0:print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_loader)}], Loss: {loss.item():.4f}')# 驗證模型model.eval()with torch.no_grad():correct = 0total = 0for images, labels in test_loader:outputs = model(images)_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()print(f'Epoch [{epoch+1}/{num_epochs}], Accuracy: {100 * correct / total:.2f}%')# 保存模型
torch.save(model.state_dict(), 'crnn_model.pth')

代碼說明

  1. CRNN模型定義：

    • 卷積層：使用四個卷積層，每個卷積層后跟著一個ReLU激活函數和一個最大池化層。
    • 全連接層：將卷積層的輸出展平后通過一個全連接層。
    • 循環層：使用LSTM層處理時間序列數據。
    • 輸出層：將LSTM的輸出通過一個全連接層得到最終的分類結果。

  2. 數據預處理：

    • 使用transforms對圖像進行標準化和resize操作。

  3. 數據加載：

    • 使用datasets.CIFAR10加載CIFAR-10數據集，并創建數據加載器。

  4. 訓練和驗證：

    • 在每個epoch中，先對模型進行訓練，然后在測試集上進行驗證，計算分類準確率。

  5. 保存模型：

    • 訓練完成后，保存模型的參數到文件。

希望這個示例對你有幫助！如果有任何問題，歡迎隨時提問。

4、deepseek-r1:

以下是一個使用CRNN（卷積遞歸神經網絡）進行圖像分類的完整代碼示例，包括詳細的注釋和可運行的demo。代碼使用PyTorch框架實現。

1. 環境要求

  • Python 3.x
  • PyTorch 1.x
  • torchvision
  • matplotlib（可選，用于可視化）

2. 代碼實現

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, datasets
import numpy as np
import matplotlib.pyplot as plt# 定義CRNN模型
class CRNN(nn.Module):def __init__(self, num_classes):super(CRNN, self).__init__()# CNN部分self.cnn = nn.Sequential(# 第一層卷積nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1),# 輸出維度：(32, 224, 224)nn.ReLU(),nn.MaxPool2d(kernel_size=2, stride=2),# 輸出維度：(32, 112, 112)# 第二層卷積nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1),# 輸出維度：(64, 112, 112)nn.ReLU(),nn.MaxPool2d(kernel_size=2, stride=2)# 輸出維度：(64, 56, 56))# RNN部分self.rnn = nn.Sequential(# LSTM層nn.LSTM(input_size=64*56, hidden_size=128, num_layers=2, batch_first=True))# 分類器self.fc = nn.Linear(128, num_classes)def forward(self, x):# CNN特征提取x = self.cnn(x)  # 輸出維度：(batch_size, 64, 56, 56)# 將CNN輸出展平并調整維度以適應RNNbatch_size = x.size(0)x = x.view(batch_size, -1, 64*56)  # 輸出維度：(batch_size, 56, 64*56)# RNN處理x, _ = self.rnn(x)  # 輸出維度：(batch_size, 56, 128)# 取最后一個時間步的輸出x = x[:, -1, :]  # 輸出維度：(batch_size, 128)# 分類x = self.fc(x)  # 輸出維度：(batch_size, num_classes)return x# 定義數據預處理
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])
])# 自定義數據集（假設數據分為good和bad兩類）
class ImageDataset(Dataset):def __init__(self, root_dir, transform=None):self.root_dir = root_dirself.transform = transformself.images = []self.labels = []# 加載good圖像good_dir = f"{root_dir}/good"for img_name in os.listdir(good_dir):if img_name.endswith('.jpg'):self.images.append(f"{good_dir}/{img_name}")self.labels.append(0)  # good為0# 加載bad圖像bad_dir = f"{root_dir}/bad"for img_name in os.listdir(bad_dir):if img_name.endswith('.jpg'):self.images.append(f"{bad_dir}/{img_name}")self.labels.append(1)  # bad為1def __len__(self):return len(self.images)def __getitem__(self, idx):img_path = self.images[idx]label = self.labels[idx]image = Image.open(img_path).convert('RGB')if self.transform:image = self.transform(image)return image, label# 數據加載
train_dataset = ImageDataset(root_dir="path_to_train_data", transform=transform)
val_dataset = ImageDataset(root_dir="path_to_val_data", transform=transform)
test_dataset = ImageDataset(root_dir="path_to_test_data", transform=transform)train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False, num_workers=4)# 初始化模型
model = CRNN(num_classes=2)# 定義損失函數和優化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)# 訓練循環
num_epochs = 10for epoch in range(num_epochs):model.train()running_loss = 0.0for images, labels in train_loader:# 前向傳播outputs = model(images)loss = criterion(outputs, labels)# 反向傳播和優化optimizer.zero_grad()loss.backward()optimizer.step()running_loss += loss.item()# 打印訓練損失print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader)}")# 驗證model.eval()val_loss = 0.0val_correct = 0with torch.no_grad():for images, labels in val_loader:outputs = model(images)loss = criterion(outputs, labels)val_loss += loss.item()_, predicted = torch.max(outputs.data, 1)val_correct += (predicted == labels).sum().item()val_accuracy = val_correct / len(val_dataset)print(f"Validation Loss: {val_loss/len(val_loader)}, Accuracy: {val_accuracy}")# 測試
model.eval()
test_correct = 0
with torch.no_grad():for images, labels in test_loader:outputs = model(images)_, predicted = torch.max(outputs.data, 1)test_correct += (predicted == labels).sum().item()test_accuracy = test_correct / len(test_dataset)
print(f"Test Accuracy: {test_accuracy}")# 可視化示例
def visualize_example():# 加載測試圖像test_images, test_labels = next(iter(test_loader))outputs = model(test_images)_, predicted = torch.max(outputs.data, 1)plt.figure(figsize=(16, 8))for i in range(4):plt.subplot(2, 4, i+1)img = test_images[i].numpy().transpose(1, 2, 0)img = (img * [0.229, 0.224, 0.225]) + [0.485, 0.456, 0.406]plt.imshow(img)plt.title(f"Predicted: {predicted[i].item()}, Actual: {test_labels[i].item()}")plt.axis('off')plt.show()visualize_example()

3. 代碼說明

1. 模型結構
  • CNN部分：用于提取圖像特征，包含兩個卷積層和兩個最大池化層。
  • RNN部分：使用LSTM處理序列特征，提取時序信息。
  • 分類器：全連接層用于最終分類。
2. 數據預處理
  • 圖像resize到224x224
  • 轉換為Tensor
  • 標準化處理
3. 數據集
  • 自定義數據集類ImageDataset，支持自定義數據路徑。
  • 數據分為good和bad兩類，分別對應標簽0和1。
4. 訓練與驗證
  • 使用交叉熵損失函數CrossEntropyLoss
  • 優化器選擇Adam
  • 每個epoch進行訓練和驗證，打印損失和準確率。
5. 測試與可視化
  • 在測試集上評估模型性能。
  • 隨機選擇4張測試圖像進行可視化，顯示預測結果與真實標簽。

4. 使用說明

  1. 替換path_to_train_data、path_to_val_data和path_to_test_data為實際數據路徑。
  2. 確保數據目錄結構如下：
    train_data/good/img1.jpgimg2.jpg...bad/imgA.jpgimgB.jpg...
val_data/good/...bad/...
test_data/good/...bad/...
  3. 運行代碼，訓練模型并查看結果。

5. 依賴安裝

pip install torch torchvision matplotlib

希望這段代碼對您有所幫助！如果需要進一步調整或優化，可以根據具體需求修改網絡結構、優化器參數或數據預處理步驟。

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/diannao/70341.shtml
繁體地址，請注明出處：http://hk.pswp.cn/diannao/70341.shtml
英文地址，請注明出處：http://en.pswp.cn/diannao/70341.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

DeepBI助力跨境電商打破流量壟斷：AI驅動的亞馬遜廣告投放新打法

DeepBI助力跨境電商打破流量壟斷：AI驅動的亞馬遜廣告投放新打法

#亞馬遜廣告優化# 親愛的亞馬遜跨境電商賣家們，是否曾因亞馬遜的廣告打法不清晰，或是糾結于亞馬遜廣告費用過高，或是為亞馬遜電商廣告怎么投放合適的問題而苦惱？在競爭激烈的亞馬遜市場中，廣告投放效果平平&#xff0…
閱讀更多...
前端基礎入門：HTML、CSS 和 JavaScript

前端基礎入門：HTML、CSS 和 JavaScript

在現代網頁開發中，前端技術扮演著至關重要的角色。無論是個人網站、企業官網，還是復雜的 Web 應用程序，前端開發的基礎技術 HTML、CSS 和 JavaScript 都是每個開發者必須掌握的核心技能。本文將詳細介紹這三者的基本概念及其應用 一、HTML——網頁的骨架 HTML（HyperText …
閱讀更多...
單元測試junit5

單元測試junit5

一、idea 安裝自動化生成插件jcode5 安裝可能不成功&#xff0c;嘗試多次安裝&#xff1b; 安裝成功后&#xff0c;重啟idea&#xff0c;再次確認安裝是否成功&#xff1b; 二、在需要生成單元測試代碼的模塊的pom中引入依賴 ......<parent><groupId>org.springf…
閱讀更多...
windows系統本地部署DeepSeek-R1全流程指南：Ollama+Docker+OpenWebUI

windows系統本地部署DeepSeek-R1全流程指南：Ollama+Docker+OpenWebUI

本文將手把手教您使用OllamaDockerOpenWebUI三件套在本地部署DeepSeek-R1大語言模型&#xff0c;實現私有化AI服務搭建。 一、環境準備 1.1 硬件要求 CPU&#xff1a;推薦Intel i7及以上&#xff08;需支持AVX2指令集&#xff09; 內存&#xff1a;最低16GB&#xff0c;推薦…
閱讀更多...
Windows Server 任務計劃

Windows Server 任務計劃

背景&#xff1a;QMT服務只能在windows服務器上面運行 直接在控制面板里面搜索"任務計劃"點進去 需要注意的是&#xff1a; 1.創建任務計劃選擇”不管用戶是否登錄都運行“&#xff0c;是否需要最高權限執行看你的需求 2.操作程序或腳本&#xff0c;選擇bat腳本就…
閱讀更多...
makefile+LSF

makefile+LSF

LSF LSF&#xff08;Load Sharing Facility&#xff09;是一種常用的集群作業調度系統&#xff0c;bsub 命令用于提交作業到 LSF 集群&#xff0c;而若要關閉&#xff08;終止&#xff09;一個正在運行的作業&#xff0c;需要使用 bkill 命令&#xff0c;下面為你詳細介紹相關…
閱讀更多...
spring boot知識點3

spring boot知識點3

1.spring boot能否使用xml配置 可以&#xff0c;但是很繁瑣&#xff0c;現在都建議走JavaConfig 2.spring boot的核心配置文件 application.properties application.yml 3.bootstrap.properties和application.properties的區別 b&#xff1a;用于遠程配置 a&#xff1a;…
閱讀更多...
人工智能學習環境配置

人工智能學習環境配置

文章目錄 Python、CUDA、cuDNN、PyTorch 和 Anaconda 的介紹PythonCUDAcuDNNPyTorchAnaconda聯系 安裝n卡驅動更新安裝 AnacondaAnaconda配置鏡像源CUDA安裝Cudnn安裝Anaconda初始化創建虛擬環境安裝 PyTorch驗證安裝 可能的錯誤SSL錯誤 Python、CUDA、cuDNN、PyTorch 和 Anaco…
閱讀更多...
【C語言】C語言 食堂自動化管理系統（源碼+數據文件）【獨一無二】

【C語言】C語言 食堂自動化管理系統（源碼+數據文件）【獨一無二】

&#x1f449;博__主&#x1f448;&#xff1a;米碼收割機 &#x1f449;技__能&#x1f448;&#xff1a;C/Python語言 &#x1f449;專__注&#x1f448;&#xff1a;專注主流機器人、人工智能等相關領域的開發、測試技術。 【C語言】C語言 食堂自動化管理系統&#xff08;源…
閱讀更多...
DeepSeek是什么？兩種模型的對比？

DeepSeek是什么？兩種模型的對比？

最近DeepSeek的風也是很大&#xff0c;它也是很火&#xff0c;那么DeepSeek是什么呢&#xff1f; 什么是DeepSeek&#xff1f; DeepSeek是一家專注通用人工智能&#xff08;AGI&#xff09;的中國科技公司&#xff0c;主攻大模型研發與應用。DeepSeek-R1是其開源的推理模型&a…
閱讀更多...
【架構】分層架構 (Layered Architecture)

【架構】分層架構 (Layered Architecture)

一、分層模型基礎理論 ![在這里插入圖片描述](https://i-blog.csdnimg.cn/direct/0365cf0bfa754229bdedca6b472bffc7.png 1. 核心定義 分層架構（Layered Architecture）模型是一種常見的軟件設計架構，它將軟件系統按照功能劃分為不同的層次，每個層次都有特定的職責和功能…
閱讀更多...
基于MATLAB的均勻面陣MUSIC算法DOA估計仿真

基于MATLAB的均勻面陣MUSIC算法DOA估計仿真

基于MATLAB的均勻面陣MUSIC算法DOA估計仿真 文章目錄 前言一、二維MUSIC算法原理二、二維MUSIC算法MATLAB仿真三、MATLAB源代碼總結 前言 \;\;\;\;\; 在波達角估計算法中&#xff0c;MUSIC 算法與ESPRIT算法屬于特征結構子空間算法&#xff0c;是波達角估計算法中的基石。在前面…
閱讀更多...
組學數據分析實操系列 |（四） 富集氣泡圖的繪制

組學數據分析實操系列 |（四） 富集氣泡圖的繪制

前言:在上一篇中&#xff0c;我們介紹了利用Metascape零代碼實現富集分析&#xff0c;但是Metascape的富集分析結果是以柱狀圖的形式展示的。文章中更常使用的富集結果可視化方式是氣泡圖。氣泡圖可以通過氣泡的坐標、形狀、顏色、大小等來展示更加豐富的富集分析結果&#xff…
閱讀更多...
實現一個專注應用-后端開發(一)-搭建

實現一個專注應用-后端開發(一)-搭建

搭建后端服務 搭建服務拆分下用戶服務 增加公共庫通用模塊 運行一下接入數據庫安裝Prisma增加prisma庫 redis增加redis服務 搭建服務 使用nestjs來做 這里是nestjs的網站Nestjs 安裝 nest npm i -g nestjs/cli創建一個項目 并在開發工具打開 nest new todonest new xx 是新…
閱讀更多...
C++17并行化加速STL算法——std::execution

C++17并行化加速STL算法——std::execution

C17 并行化STL算法 文章目錄 C17 并行化STL算法概念環境準備工具類 并行算法 - 使用并行算法 - 執行策略總覽選擇標準詳細介紹順序執行 seq并行化順序執行 par并行化亂序執行 par_unseq 并行算法 - 異常處理可以不使用并行算法并行算法 - 限制并行算法有哪些原有算法17引入新算…
閱讀更多...
Deepseek 懟CHATGPT實況

Deepseek 懟CHATGPT實況

提示詞&#xff1a; 用犀利的語言批評ChatGPT 深度思考&#xff08;R1) 嗯&#xff0c;用戶讓我用犀利的語言批評ChatGPT。首先&#xff0c;我需要理解他們的動機。可能他們遇到了ChatGPT的某些問題&#xff0c;比如回答不準確或者缺乏深度&#xff0c;所以想表達不滿。也有…
閱讀更多...
always和assign語法區別

always和assign語法區別

always語句可以帶時鐘， 也可以不帶時鐘。 一，assign和always區別 assign 語句使用時不能帶時鐘。 assign a=1; assign b=2; 在always不帶時鐘時，邏輯功能和assign完全一致，都是只產生組合邏輯。比較簡單的組合邏輯推薦使用assign語句，比較復雜的組合邏輯推薦使用 al…
閱讀更多...
解析跨域：原理、解決方案與實踐指南

解析跨域：原理、解決方案與實踐指南

解析跨域&#xff1a;原理、解決方案與實踐指南 &#x1f310; 在現代Web開發中&#xff0c;跨域問題是一個常見且重要的挑戰。隨著互聯網應用的日益復雜&#xff0c;前端與后端之間的交互越來越頻繁&#xff0c;跨域請求的需求也隨之增加。 一、跨域問題的本質與產生條件 &a…
閱讀更多...
鴻蒙開發：熟知@BuilderParam裝飾器

鴻蒙開發：熟知@BuilderParam裝飾器

前言 本文代碼案例基于Api13。 在實際的開發中&#xff0c;我們經常會遇到自定義組件的情況&#xff0c;比如通用的列表組件&#xff0c;選項卡組件等等&#xff0c;由于使用方的樣式不一&#xff0c;子組件是動態變化的&#xff0c;針對這一情況&#xff0c;就不得不讓使用方把…
閱讀更多...
MSI微星電腦沖鋒坦克Pro Vector GP76 12UGS(MS-17K4)原廠Win11系統恢復鏡像，含還原功能，預裝OEM系統下載

MSI微星電腦沖鋒坦克Pro Vector GP76 12UGS(MS-17K4)原廠Win11系統恢復鏡像，含還原功能，預裝OEM系統下載

適用機型&#xff1a;【MS-17K4】 鏈接&#xff1a;https://pan.baidu.com/s/1P8ZgXc6S_J9DI8RToRd0dQ?pwdqrf1 提取碼&#xff1a;qrf1 微星筆記本原裝出廠WINDOWS11系統自帶所有驅動、出廠主題壁紙、系統屬性專屬聯機支持標志、Office辦公軟件、MSI Center控制中心等預裝…
閱讀更多...
最新文章

Copyright @ 2022~2023