rnn判断string中第一次出现a的下标

news2026/2/27 5:57:24 
# coding:utf8
import torch
import torch.nn as nn
import numpy as np
import random
import json

"""
基于pytorch的网络编写
实现一个RNN网络完成多分类任务
判断字符 'a' 第一次出现在字符串中的位置
"""


class TorchModel(nn.Module):
    def __init__(self, vector_dim, sentence_length, vocab, num_classes):
        super(TorchModel, self).__init__()
        self.embedding = nn.Embedding(len(vocab), vector_dim, padding_idx=0)  # embedding层
        self.rnn = nn.GRU(vector_dim, vector_dim, batch_first=True)  # RNN层
        self.classify = nn.Linear(vector_dim, num_classes)  # 线性层
        self.loss = nn.CrossEntropyLoss()  # loss函数采用交叉熵损失

    # 当输入真实标签，返回loss值；无真实标签，返回预测值
    def forward(self, x, y=None):
        x = self.embedding(x)  # (batch_size, sen_len) -> (batch_size, sen_len, vector_dim)
        _, hidden = self.rnn(x)  # (batch_size, sen_len, vector_dim) -> (1, batch_size, vector_dim)
        hidden = hidden.squeeze(0)  # (1, batch_size, vector_dim) -> (batch_size, vector_dim)
        y_pred = self.classify(hidden)  # (batch_size, vector_dim) -> (batch_size, num_classes)
        if y is not None:
            return self.loss(y_pred, y)  # 预测值和真实值计算损失
        else:
            return torch.softmax(y_pred, dim=1)  # 输出预测概率分布


# 字符集
def build_vocab():
    chars = "abcdefghijklmnopqrstuvwxyz"  # 字符集
    vocab = {"pad": 0}
    for index, char in enumerate(chars):
        vocab[char] = index + 1  # 每个字对应一个序号
    vocab['unk'] = len(vocab)  # 未知字符
    return vocab


# 随机生成一个样本
def build_sample(vocab, sentence_length):
    # 随机从字表选取sentence_length个字，可能重复
    x = [random.choice(list(vocab.keys())) for _ in range(sentence_length)]

    # 确保每个样本都包含字符 'a'
    a_position = random.randint(0, sentence_length - 1)
    x[a_position] = 'a'

    # 将字转换成序号
    x = [vocab.get(word, vocab['unk']) for word in x]
    return x, a_position


# 建立数据集
def build_dataset(sample_length, vocab, sentence_length):
    dataset_x = []
    dataset_y = []
    for i in range(sample_length):
        x, y = build_sample(vocab, sentence_length)
        dataset_x.append(x)
        dataset_y.append(y)
    return torch.LongTensor(dataset_x), torch.LongTensor(dataset_y)


# 建立模型
def build_model(vocab, char_dim, sentence_length):
    num_classes = sentence_length  # 分类数等于句子长度（每个位置一个类别）
    model = TorchModel(char_dim, sentence_length, vocab, num_classes)
    return model


# 测试代码
def evaluate(model, vocab, sentence_length):
    model.eval()
    x, y = build_dataset(200, vocab, sentence_length)  # 建立200个用于测试的样本
    correct, wrong = 0, 0
    with torch.no_grad():
        y_pred = model(x)  # 模型预测
        y_pred = torch.argmax(y_pred, dim=1)  # 获取预测的类别
        for y_p, y_t in zip(y_pred, y):  # 与真实标签进行对比
            if y_p == y_t:
                correct += 1
            else:
                wrong += 1
    print("正确预测个数：%d, 正确率：%f" % (correct, correct / (correct + wrong)))
    return correct / (correct + wrong)


def main():
    # 配置参数
    epoch_num = 30  # 训练轮数
    batch_size = 20  # 每次训练样本个数
    train_sample = 500  # 每轮训练总共训练的样本总数
    char_dim = 20  # 每个字的维度
    sentence_length = 6  # 样本文本长度
    learning_rate = 0.005  # 学习率

    # 建立字表
    vocab = build_vocab()

    # 建立模型
    model = build_model(vocab, char_dim, sentence_length)

    # 选择优化器
    optim = torch.optim.Adam(model.parameters(), lr=learning_rate)
    log = []

    # 训练过程
    for epoch in range(epoch_num):
        model.train()
        watch_loss = []
        for batch in range(int(train_sample / batch_size)):
            x, y = build_dataset(batch_size, vocab, sentence_length)  # 构造一组训练样本
            optim.zero_grad()  # 梯度归零
            loss = model(x, y)  # 计算loss
            loss.backward()  # 计算梯度
            optim.step()  # 更新权重
            watch_loss.append(loss.item())
        print("=========\n第%d轮平均loss:%f" % (epoch + 1, np.mean(watch_loss)))
        acc = evaluate(model, vocab, sentence_length)  # 测试本轮模型结果
        log.append([acc, np.mean(watch_loss)])

    # 保存模型
    torch.save(model.state_dict(), "model.pth")

    # 保存词表
    with open("vocab.json", "w", encoding="utf8") as writer:
        writer.write(json.dumps(vocab, ensure_ascii=False, indent=2))

    # 生成200个随机测试样本
    test_strings = []
    for _ in range(200):
        # 随机生成一个包含字符 'a' 的字符串
        chars = list("abcdefghijklmnopqrstuvwxyz")
        s = [random.choice(chars) for _ in range(sentence_length)]
        a_pos = random.randint(0, sentence_length - 1)
        s[a_pos] = 'a'  # 确保字符串中包含 'a'
        test_strings.append(''.join(s))

    # 用模型预测并输出结果
    print("\n随机生成的200个测试样本预测结果：")
    predict("model.pth", "vocab.json", test_strings)


# 使用训练好的模型做预测
def predict(model_path, vocab_path, input_strings):
    char_dim = 20  # 每个字的维度
    sentence_length = 6  # 样本文本长度

    # 加载字符表
    vocab = json.load(open(vocab_path, "r", encoding="utf8"))

    # 建立模型
    model = build_model(vocab, char_dim, sentence_length)

    # 加载训练好的权重
    model.load_state_dict(torch.load(model_path))

    x = []
    for input_string in input_strings:
        # 将输入字符串转换为字符序号列表，并进行填充
        seq = [vocab.get(char, vocab['unk']) for char in input_string]
        if len(seq) < sentence_length:
            seq = seq + [vocab['pad']] * (sentence_length - len(seq))
        else:
            seq = seq[:sentence_length]
        x.append(seq)

    model.eval()  # 测试模式
    with torch.no_grad():  # 不计算梯度
        result = model.forward(torch.LongTensor(x))  # 模型预测

    # 只打印前10个结果和最后10个结果，避免输出过多
    if len(input_strings) > 20:
        display_indices = list(range(10)) + list(range(len(input_strings) - 10, len(input_strings)))
        for i in display_indices:
            predicted_position = torch.argmax(result[i]).item()
            print(f"输入：{input_strings[i]}, 预测类别：{predicted_position}, 概率分布：{result[i].numpy()}")
        print(f"... 中间省略 {len(input_strings) - 20} 个结果 ...")
    else:
        for i, input_string in enumerate(input_strings):
            predicted_position = torch.argmax(result[i]).item()
            print(f"输入：{input_string}, 预测类别：{predicted_position}, 概率分布：{result[i].numpy()}")


if __name__ == "__main__":
    main()


预测率百分之90

改进优化

要提升模型准确率，可以从数据、模型架构、训练策略等多方面优化。以下是针对你提供的 RNN 模型的具体改进方案，结合代码实现，逐步提升准确率：

一、数据增强与预处理优化

1. 增加数据多样性（解决过拟合）
  • 问题：原数据仅包含 26 个字母，且强制每个样本包含a，可能导致模型泛化能力不足。
  • 改进：
    • 允许样本不包含a（需新增类别-1或视为无效样本），或在预测时将 “无 a” 作为特殊类别。
    • 引入更多字符（如标点、大写字母），提升输入多样性。
2. 延长序列长度（适配更长文本）
  • 问题：固定sentence_length=6限制了模型处理更长序列的能力。
  • 改进：
    • 动态填充序列，允许输入长度可变（需修改 RNN 层为pack_padded_sequence）。
    • 增加最大序列长度（如设为 10），生成更多样化的样本。

代码调整示例：

python

运行

# 允许序列长度可变（以最大长度10为例）
sentence_length = 10  
x, y = build_sample(vocab, sentence_length)  # 生成长度为10的样本

二、模型架构优化

1. 改用双向 RNN（捕捉上下文信息）
  • 问题：单向 GRU 仅能捕捉上文信息，无法利用下文语境。
  • 改进：使用nn.BiGRU替换单向 GRU，增强特征提取能力。

代码调整：

python

运行

class TorchModel(nn.Module):
    def __init__(self, vector_dim, sentence_length, vocab, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(len(vocab), vector_dim, padding_idx=0)
        # 双向GRU，输出维度翻倍（hidden_size * 2）
        self.rnn = nn.BiGRU(vector_dim, vector_dim, batch_first=True, bidirectional=True)  
        self.classify = nn.Linear(vector_dim * 2, num_classes)  # 线性层输入维度改为2*vector_dim
        self.loss = nn.CrossEntropyLoss()
2. 增加网络层数与隐藏层维度
  • 问题：单层 GRU 表达能力有限，隐藏层维度（20）较小。
  • 改进：
    • 增加 GRU 层数（如num_layers=2）。
    • 增大隐藏层维度（如vector_dim=32）。

代码调整：

python

运行

self.rnn = nn.BiGRU(vector_dim, vector_dim, batch_first=True, bidirectional=True, num_layers=2)

三、训练策略优化

1. 调整学习率与优化器
  • 问题：初始学习率（0.005）可能过高，导致收敛不稳定。
  • 改进：
    • 降低学习率（如lr=0.001），并使用学习率衰减（StepLR）。
    • 改用更鲁棒的优化器（如AdamW），减少过拟合。

代码调整：

python

运行

from torch.optim import lr_scheduler

optim = torch.optim.AdamW(model.parameters(), lr=0.001)
scheduler = lr_scheduler.StepLR(optim, step_size=5, gamma=0.9)  # 每5轮衰减学习率

for epoch in range(epoch_num):
    # 训练...
    scheduler.step()  # 更新学习率
2. 增加正则化（防止过拟合）
  • 问题：模型可能在训练集上过拟合，导致测试集准确率下降。
  • 改进：
    • 在 RNN 层后添加Dropout层。
    • 在损失函数中添加权重衰减（L2 正则）。

代码调整：

python

运行

class TorchModel(nn.Module):
    def __init__(self, vector_dim, sentence_length, vocab, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(len(vocab), vector_dim, padding_idx=0)
        self.rnn = nn.BiGRU(vector_dim, vector_dim, batch_first=True, bidirectional=True, num_layers=2)
        self.dropout = nn.Dropout(0.2)  # 添加Dropout层
        self.classify = nn.Linear(vector_dim * 2, num_classes)
        self.loss = nn.CrossEntropyLoss()

    def forward(self, x, y=None):
        x = self.embedding(x)
        out, hidden = self.rnn(x)
        out = self.dropout(out)  # 在RNN输出后应用Dropout
        # 取最后一个时间步的隐藏状态（双向合并）
        hidden = torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1)  # 双向GRU的隐藏状态拼接
        y_pred = self.classify(hidden)
        # ...

四、预测逻辑优化

1. 利用序列所有时间步输出（而非仅最后隐藏状态）
  • 问题：原模型仅使用最后一个时间步的隐藏状态，忽略中间时间步的信息。
  • 改进：对 RNN 的所有时间步输出取平均或池化，获取更全面的特征。

代码调整：

python

运行

def forward(self, x, y=None):
    x = self.embedding(x)
    out, _ = self.rnn(x)  # out shape: (batch_size, seq_len, hidden_size*2)
    out = self.dropout(out)
    # 平均池化：对所有时间步取平均
    out = torch.mean(out, dim=1)  
    y_pred = self.classify(out)
    # ...

五、完整优化后代码（关键部分）

python

运行

class TorchModel(nn.Module):
    def __init__(self, vector_dim, sentence_length, vocab, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(len(vocab), vector_dim, padding_idx=0)
        self.rnn = nn.BiGRU(
            vector_dim, 
            vector_dim, 
            batch_first=True, 
            bidirectional=True, 
            num_layers=2, 
            dropout=0.2  # 层间Dropout
        )
        self.dropout = nn.Dropout(0.3)
        self.classify = nn.Linear(vector_dim * 2, num_classes)
        self.loss = nn.CrossEntropyLoss()

    def forward(self, x, y=None):
        x = self.embedding(x)  # (batch, seq_len, vec_dim)
        out, _ = self.rnn(x)  # (batch, seq_len, 2*vec_dim)
        out = self.dropout(out)
        # 平均池化替代仅取最后隐藏状态
        out = torch.mean(out, dim=1)  # (batch, 2*vec_dim)
        y_pred = self.classify(out)
        if y is not None:
            return self.loss(y_pred, y)
        else:
            return torch.softmax(y_pred, dim=1)

# 训练配置优化
epoch_num = 50  # 增加训练轮数
batch_size = 32  # 增大批量大小
train_sample = 2000  # 增加训练样本数量
char_dim = 32  # 增大词向量维度
learning_rate = 0.001  # 降低学习率

六、预期效果

  • 准确率提升：通过双向 RNN、数据增强、正则化等优化，测试集准确率可从 90% 提升至95% 以上。
  • 泛化能力增强：模型能更好处理不同长度序列、字符分布变化的情况。

注意：实际效果需根据数据规模和硬件条件调整，建议逐步验证单一优化项的影响（如先加双向 RNN，再加数据增强），定位关键改进点。

# coding:utf8
import torch
import torch.nn as nn
import numpy as np
import random
import json
from torch.optim import lr_scheduler

"""
基于pytorch的网络编写
实现一个RNN网络完成多分类任务
判断字符 'a' 第一次出现在字符串中的位置
"""


class TorchModel(nn.Module):
    def __init__(self, vector_dim, sentence_length, vocab, num_classes):
        super(TorchModel, self).__init__()
        self.embedding = nn.Embedding(len(vocab), vector_dim, padding_idx=0)  # embedding层
        # 修复：使用nn.GRU并设置bidirectional=True实现双向GRU
        self.rnn = nn.GRU(
            vector_dim,
            vector_dim,
            batch_first=True,
            bidirectional=True,
            num_layers=2,  # 2层网络
            dropout=0.2  # 层间dropout
        )
        self.dropout = nn.Dropout(0.3)  # 输出层dropout
        self.classify = nn.Linear(vector_dim * 2, num_classes)  # 线性层，输入维度需乘以2（双向）
        self.loss = nn.CrossEntropyLoss()  # loss函数采用交叉熵损失

    # 当输入真实标签，返回loss值；无真实标签，返回预测值
    def forward(self, x, y=None):
        x = self.embedding(x)  # (batch_size, sen_len) -> (batch_size, sen_len, vector_dim)
        out, _ = self.rnn(x)  # (batch_size, sen_len, vector_dim*2)
        out = self.dropout(out)
        # 使用平均池化替代仅最后时间步的隐藏状态，捕获更全面的序列信息
        out = torch.mean(out, dim=1)  # (batch_size, vector_dim*2)
        y_pred = self.classify(out)  # (batch_size, num_classes)
        if y is not None:
            return self.loss(y_pred, y)  # 预测值和真实值计算损失
        else:
            return torch.softmax(y_pred, dim=1)  # 输出预测概率分布


# 字符集，增加多样性
def build_vocab():
    chars = "abcdefghijklmnopqrstuvwxyz0123456789,.!?-_"  # 增加数字和符号
    vocab = {"pad": 0}
    for index, char in enumerate(chars):
        vocab[char] = index + 1  # 每个字对应一个序号
    vocab['unk'] = len(vocab)  # 未知字符
    return vocab


# 随机生成一个样本，支持更灵活的配置
def build_sample(vocab, sentence_length, force_a=True):
    # 随机从字表选取sentence_length个字，可能重复
    x = [random.choice(list(vocab.keys())) for _ in range(sentence_length)]

    # 控制字符 'a' 的出现概率，增加数据多样性
    if force_a or random.random() > 0.2:  # 80%的概率包含 'a'
        a_position = random.randint(0, sentence_length - 1)
        x[a_position] = 'a'

        # 将字符转换为对应的索引
        x_indices = [vocab.get(char, vocab['unk']) for char in x]
        return x_indices, a_position
    else:
        # 不包含 'a' 的情况，类别设为 -1（实际训练时会被过滤）
        x_indices = [vocab.get(char, vocab['unk']) for char in x]
        return x_indices, -1


# 建立数据集，支持更灵活的配置
def build_dataset(sample_length, vocab, sentence_length, force_a=True):
    dataset_x = []
    dataset_y = []
    for i in range(sample_length):
        x, y = build_sample(vocab, sentence_length, force_a)
        # 过滤掉不包含 'a' 的样本（y=-1）
        if y != -1:
            dataset_x.append(x)
            dataset_y.append(y)

    # 确保有数据可用
    if len(dataset_x) == 0:
        raise ValueError("生成的样本中没有符合条件的样本（全部不包含 'a'）")

    return torch.LongTensor(dataset_x), torch.LongTensor(dataset_y)


# 建立模型
def build_model(vocab, char_dim, sentence_length):
    num_classes = sentence_length  # 分类数等于句子长度（每个位置一个类别）
    model = TorchModel(char_dim, sentence_length, vocab, num_classes)
    return model


# 测试代码
def evaluate(model, vocab, sentence_length):
    model.eval()
    x, y = build_dataset(500, vocab, sentence_length, force_a=True)  # 使用500个样本评估
    correct, wrong = 0, 0
    with torch.no_grad():
        y_pred = model(x)  # 模型预测
        y_pred = torch.argmax(y_pred, dim=1)  # 获取预测的类别
        for y_p, y_t in zip(y_pred, y):  # 与真实标签进行对比
            if y_p == y_t:
                correct += 1
            else:
                wrong += 1
    accuracy = correct / (correct + wrong)
    print(f"正确预测个数：{correct}, 总样本数：{correct + wrong}, 正确率：{accuracy:.4f}")
    return accuracy


def main():
    # 配置参数
    epoch_num = 50  # 增加训练轮数
    batch_size = 32  # 增大batch size
    train_sample = 2000  # 增加训练样本数量
    char_dim = 32  # 增大词向量维度
    sentence_length = 8  # 增加句子长度，提高任务难度
    learning_rate = 0.001  # 降低初始学习率

    # 建立字表
    vocab = build_vocab()

    # 建立模型
    model = build_model(vocab, char_dim, sentence_length)

    # 选择优化器，使用AdamW（带权重衰减的Adam）
    optim = torch.optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=1e-4)
    # 学习率调度器，每10轮降低学习率
    scheduler = lr_scheduler.StepLR(optim, step_size=10, gamma=0.5)
    log = []

    # 训练过程
    for epoch in range(epoch_num):
        model.train()
        watch_loss = []
        for batch in range(int(train_sample / batch_size)):
            x, y = build_dataset(batch_size, vocab, sentence_length)  # 构造一组训练样本
            optim.zero_grad()  # 梯度归零
            loss = model(x, y)  # 计算loss
            loss.backward()  # 计算梯度
            optim.step()  # 更新权重
            watch_loss.append(loss.item())

        # 更新学习率
        scheduler.step()

        # 打印当前学习率
        current_lr = scheduler.get_last_lr()[0]

        print(f"=========\n第{epoch + 1}/{epoch_num}轮，平均loss:{np.mean(watch_loss):.4f}，学习率:{current_lr:.6f}")
        acc = evaluate(model, vocab, sentence_length)  # 测试本轮模型结果
        log.append([acc, np.mean(watch_loss)])

    # 保存模型
    torch.save(model.state_dict(), "model_optimized.pth")

    # 保存词表
    with open("vocab_optimized.json", "w", encoding="utf8") as writer:
        writer.write(json.dumps(vocab, ensure_ascii=False, indent=2))

    # 生成200个随机测试样本
    test_strings = []
    for _ in range(200):
        # 随机生成一个包含字符 'a' 的字符串
        chars = list("abcdefghijklmnopqrstuvwxyz0123456789,.!?-_")
        s = [random.choice(chars) for _ in range(sentence_length)]
        a_pos = random.randint(0, sentence_length - 1)
        s[a_pos] = 'a'  # 确保字符串中包含 'a'
        test_strings.append(''.join(s))

    # 用模型预测并输出结果
    print("\n随机生成的200个测试样本预测结果（展示前10个和后10个）：")
    predict("model_optimized.pth", "vocab_optimized.json", test_strings)


# 使用训练好的模型做预测
def predict(model_path, vocab_path, input_strings):
    char_dim = 32  # 与训练时保持一致
    sentence_length = 8  # 与训练时保持一致

    # 加载字符表
    vocab = json.load(open(vocab_path, "r", encoding="utf8"))

    # 建立模型
    model = build_model(vocab, char_dim, sentence_length)

    # 加载训练好的权重
    model.load_state_dict(torch.load(model_path))

    x = []
    for input_string in input_strings:
        # 将输入字符串转换为字符序号列表，并进行填充
        seq = [vocab.get(char, vocab['unk']) for char in input_string]
        if len(seq) < sentence_length:
            seq = seq + [vocab['pad']] * (sentence_length - len(seq))
        else:
            seq = seq[:sentence_length]
        x.append(seq)

    model.eval()  # 测试模式
    with torch.no_grad():  # 不计算梯度
        result = model.forward(torch.LongTensor(x))  # 模型预测

    # 只打印前10个结果和最后10个结果，避免输出过多
    if len(input_strings) > 20:
        display_indices = list(range(10)) + list(range(len(input_strings) - 10, len(input_strings)))
        for i in display_indices:
            predicted_position = torch.argmax(result[i]).item()
            print(f"输入：{input_strings[i]}, 预测类别：{predicted_position}, 概率分布：{result[i].numpy()}")
        print(f"... 中间省略 {len(input_strings) - 20} 个结果 ...")
    else:
        for i, input_string in enumerate(input_strings):
            predicted_position = torch.argmax(result[i]).item()
            print(f"输入：{input_strings[i]}, 预测类别：{predicted_position}, 概率分布：{result[i].numpy()}")


if __name__ == "__main__":
    main()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2407386.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Unsafe Fileupload篇补充-木马的详细教程与木马分享（中国蚁剑方式）

Unsafe Fileupload篇补充-木马的详细教程与木马分享（中国蚁剑方式）

在之前的皮卡丘靶场第九期Unsafe Fileupload篇中我们学习了木马的原理并且学了一个简单的木马文件 本期内容是为了更好的为大家解释木马&#xff08;服务器方面的&#xff09;的原理&#xff0c;连接&#xff0c;以及各种木马及连接工具的分享 文件木马&#xff1a;https://w…
阅读更多...
深度学习习题2

深度学习习题2

1.如果增加神经网络的宽度&#xff0c;精确度会增加到一个特定阈值后&#xff0c;便开始降低。造成这一现象的可能原因是什么&#xff1f; A、即使增加卷积核的数量&#xff0c;只有少部分的核会被用作预测 B、当卷积核数量增加时&#xff0c;神经网络的预测能力会降低 C、当卷…
阅读更多...
10-Oracle 23 ai Vector Search 概述和参数

10-Oracle 23 ai Vector Search 概述和参数

一、Oracle AI Vector Search 概述 企业和个人都在尝试各种AI&#xff0c;使用客户端或是内部自己搭建集成大模型的终端&#xff0c;加速与大型语言模型&#xff08;LLM&#xff09;的结合&#xff0c;同时使用检索增强生成&#xff08;Retrieval Augmented Generation &#…
阅读更多...
Reasoning over Uncertain Text by Generative Large Language Models

Reasoning over Uncertain Text by Generative Large Language Models

https://ojs.aaai.org/index.php/AAAI/article/view/34674/36829https://ojs.aaai.org/index.php/AAAI/article/view/34674/36829 1. 概述 文本中的不确定性在许多语境中传达，从日常对话到特定领域的文档（例如医学文档）（Heritage 2013；Landmark、Gulbrandsen 和 Svenevei…
阅读更多...
华硕a豆14 Air香氛版，美学与科技的馨香融合

华硕a豆14 Air香氛版，美学与科技的馨香融合

在快节奏的现代生活中&#xff0c;我们渴望一个能激发创想、愉悦感官的工作与生活伙伴&#xff0c;它不仅是冰冷的科技工具&#xff0c;更能触动我们内心深处的细腻情感。正是在这样的期许下&#xff0c;华硕a豆14 Air香氛版翩然而至&#xff0c;它以一种前所未有的方式&#x…
阅读更多...
云原生玩法三问：构建自定义开发环境

云原生玩法三问：构建自定义开发环境

云原生玩法三问&#xff1a;构建自定义开发环境 引言 临时运维一个古董项目&#xff0c;无文档&#xff0c;无环境&#xff0c;无交接人&#xff0c;俗称三无。 运行设备的环境老&#xff0c;本地环境版本高&#xff0c;ssh不过去。正好最近对 腾讯出品的云原生 cnb 感兴趣&…
阅读更多...
以光量子为例，详解量子获取方式

以光量子为例，详解量子获取方式

光量子技术获取量子比特可在室温下进行。该方式有望通过与名为硅光子学&#xff08;silicon photonics&#xff09;的光波导&#xff08;optical waveguide&#xff09;芯片制造技术和光纤等光通信技术相结合来实现量子计算机。量子力学中&#xff0c;光既是波又是粒子。光子本…
阅读更多...
html css js网页制作成品——HTML+CSS榴莲商城网页设计（4页）附源码

html css js网页制作成品——HTML+CSS榴莲商城网页设计（4页）附源码

目录 一、&#x1f468;‍&#x1f393;网站题目 二、✍️网站描述 三、&#x1f4da;网站介绍 四、&#x1f310;网站效果 五、&#x1fa93; 代码实现 &#x1f9f1;HTML 六、&#x1f947; 如何让学习不再盲目 七、&#x1f381;更多干货 一、&#x1f468;‍&#x1f…
阅读更多...
九天毕昇深度学习平台 | 如何安装库？

九天毕昇深度学习平台 | 如何安装库？

pip install 库名 -i https://pypi.tuna.tsinghua.edu.cn/simple --user 举个例子&#xff1a; 报错 ModuleNotFoundError: No module named torch 那么我需要安装 torch pip install torch -i https://pypi.tuna.tsinghua.edu.cn/simple --user pip install 库名&#x…
阅读更多...
HashMap中的put方法执行流程（流程图）

HashMap中的put方法执行流程（流程图）

1 put操作整体流程 HashMap 的 put 操作是其最核心的功能之一。在 JDK 1.8 及以后版本中&#xff0c;其主要逻辑封装在 putVal 这个内部方法中。整个过程大致如下&#xff1a; 初始判断与哈希计算&#xff1a; 首先&#xff0c;putVal 方法会检查当前的 table&#xff08;也就…
阅读更多...
2025季度云服务器排行榜

2025季度云服务器排行榜

在全球云服务器市场&#xff0c;各厂商的排名和地位并非一成不变&#xff0c;而是由其独特的优势、战略布局和市场适应性共同决定的。以下是根据2025年市场趋势&#xff0c;对主要云服务器厂商在排行榜中占据重要位置的原因和优势进行深度分析&#xff1a; 一、全球“三巨头”…
阅读更多...
sipsak：SIP瑞士军刀！全参数详细教程！Kali Linux教程！

sipsak：SIP瑞士军刀！全参数详细教程！Kali Linux教程！

简介 sipsak 是一个面向会话初始协议 (SIP) 应用程序开发人员和管理员的小型命令行工具。它可以用于对 SIP 应用程序和设备进行一些简单的测试。 sipsak 是一款 SIP 压力和诊断实用程序。它通过 sip-uri 向服务器发送 SIP 请求&#xff0c;并检查收到的响应。它以以下模式之一…
阅读更多...
用机器学习破解新能源领域的“弃风”难题

用机器学习破解新能源领域的“弃风”难题

音乐发烧友深有体会&#xff0c;玩音乐的本质就是玩电网。火电声音偏暖&#xff0c;水电偏冷&#xff0c;风电偏空旷。至于太阳能发的电&#xff0c;则略显朦胧和单薄。 不知你是否有感觉&#xff0c;近两年家里的音响声音越来越冷&#xff0c;听起来越来越单薄&#xff1f; —…
阅读更多...
C++使用 new 来创建动态数组

C++使用 new 来创建动态数组

问题&#xff1a; 不能使用变量定义数组大小 原因&#xff1a; 这是因为数组在内存中是连续存储的&#xff0c;编译器需要在编译阶段就确定数组的大小&#xff0c;以便正确地分配内存空间。如果允许使用变量来定义数组的大小&#xff0c;那么编译器就无法在编译时确定数组的大…
阅读更多...
中医有效性探讨

中医有效性探讨

文章目录 西医是如何发展到以生物化学为药理基础的现代医学&#xff1f;传统医学奠基期&#xff08;远古 - 17 世纪&#xff09;近代医学转型期&#xff08;17 世纪 - 19 世纪末&#xff09;​现代医学成熟期&#xff08;20世纪至今&#xff09; 中医的源远流长和一脉相承远古至…
阅读更多...
让回归模型不再被异常值“带跑偏“，MSE和Cauchy损失函数在噪声数据环境下的实战对比

让回归模型不再被异常值“带跑偏“，MSE和Cauchy损失函数在噪声数据环境下的实战对比

在机器学习的回归分析中&#xff0c;损失函数的选择对模型性能具有决定性影响。均方误差&#xff08;MSE&#xff09;作为经典的损失函数&#xff0c;在处理干净数据时表现优异&#xff0c;但在面对包含异常值的噪声数据时&#xff0c;其对大误差的二次惩罚机制往往导致模型参数…
阅读更多...
HDFS分布式存储 zookeeper

HDFS分布式存储 zookeeper

hadoop介绍 狭义上hadoop是指apache的一款开源软件 用java语言实现开源框架&#xff0c;允许使用简单的变成模型跨计算机对大型集群进行分布式处理&#xff08;1.海量的数据存储 2.海量数据的计算&#xff09;Hadoop核心组件 hdfs&#xff08;分布式文件存储系统&#xff09;&a…
阅读更多...
佰力博科技与您探讨热释电测量的几种方法

佰力博科技与您探讨热释电测量的几种方法

热释电的测量主要涉及热释电系数的测定&#xff0c;这是表征热释电材料性能的重要参数。热释电系数的测量方法主要包括静态法、动态法和积分电荷法。其中&#xff0c;积分电荷法最为常用&#xff0c;其原理是通过测量在电容器上积累的热释电电荷&#xff0c;从而确定热释电系数…
阅读更多...
HarmonyOS运动开发：如何用mpchart绘制运动配速图表

HarmonyOS运动开发：如何用mpchart绘制运动配速图表

##鸿蒙核心技术##运动开发##Sensor Service Kit&#xff08;传感器服务&#xff09;# 前言 在运动类应用中&#xff0c;运动数据的可视化是提升用户体验的重要环节。通过直观的图表展示运动过程中的关键数据&#xff0c;如配速、距离、卡路里消耗等&#xff0c;用户可以更清晰…
阅读更多...
安宝特方案丨船舶智造的“AR+AI+作业标准化管理解决方案”（装配）

安宝特方案丨船舶智造的“AR+AI+作业标准化管理解决方案”（装配）

船舶制造装配管理现状&#xff1a;装配工作依赖人工经验&#xff0c;装配工人凭借长期实践积累的操作技巧完成零部件组装。企业通常制定了装配作业指导书&#xff0c;但在实际执行中&#xff0c;工人对指导书的理解和遵循程度参差不齐。 船舶装配过程中的挑战与需求 挑战 (1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023