Encoding.word_ids()

原创 已于 2023-04-03 17:08:39 修改 · 263 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言

于 2023-03-31 14:41:08 首次发布
该文展示了如何利用transformers库的AutoTokenizer对文本进行编码，具体操作涉及加载预训练模型google/bigbird-roberta-base，保存tokenizer，并对输入字符串ilovingyouHaarde进行编码和解码。过程中提到了wordPiece分词方法。

一、Encoding资料

Encoding

二、代码 

from transformers import AutoTokenizer

DOWNLOADED_MODEL_PATH = 'model'
tokenizer = AutoTokenizer.from_pretrained('google/bigbird-roberta-base')
tokenizer.save_pretrained('model')

encoding = tokenizer("i loving you Haarde")

print(encoding['input_ids'])
print(tokenizer.decode(encoding['input_ids']))

print(encoding.word_ids())
print(tokenizer.convert_ids_to_tokens(encoding['input_ids']))

三、输出

[65, 1413, 14543, 446, 9499, 45194, 66]

[CLS] i loving you Haarde[SEP]

[None, 0, 1, 2, 3, 3, None]
['[CLS]', '▁i', '▁loving', '▁you', '▁Ha', 'arde', '[SEP]']

 这一过程使用了wordPiece

参考文献：保姆级教程，用PyTorch和BERT进行命名实体识别

SmartDemo
关注
将transformers的tokenizer处理之后（如BPE）的序列映射回输入序列
qysh123的专栏
08-20 1503
从上面的输出中可以看到，encoded['input_ids']对应的就是输入到transformer encoder的tensor输入，.tokens()返回的是tokenize以后的token，.word_ids()返回的是tokenize以后的token的编码（而并不是输入sequence的）。为了展示方便，省略了之前很长的那些print，可以看到，最后生成的这个word_2_token_mapping是完全正确的。，这个和API文档里说的完全不一样啊。，这个表明的是在原输入序列中的位置。
阿里天池 NLP 入门赛 TextCNN 方案代码详细注释和流程讲解
张贤的博客
08-14 5053
为什么写篇文章 首先，这篇文章的代码全部都来源于 Datawhale 提供的开源代码，我添加了自己的笔记，帮助新手更好地理解这个代码。 这份代码里包含了数据处理，以及从 0 到 1模型建立的完整流程。 这份代码和前面提供的 basesline 的都不太一样，它包含了非常多数据处理的细节，模型也是由 3 个部分构成，所以看起来难度陡然上升。 其次，代码里的注释非常少，也没有讲解整个模型的整体流程。 这份代码其中很多数据转换的逻辑，和 3 个模型的连接，对于新手来说，颇为头痛。 我自己也是一个新人，花了一天的时
若一个单词被拆分成多少token, word_ids得到的序号是相同的？还是序号累加的？
薰珞婷紫小亭子的博客
04-09 1057
在使用tokenizer进行编码的时候，经常会存在word被拆分成多个token的情况，不同的参数设置，会得到不同的结果。总的来说，得到的word_ids会有两种，一种是每一个子token是相同的序号；可以看出，tokenizer对text进行了分词处理，但word_ids()的序号是一次累加的，单纯的从word_ids（）结果来看，并不能知道哪个单词被拆分了。同一个word的序号是相同的，通过word_ids()序号，就可以定位到被拆分的单词。根据自己的需求，使用不同的方法，下面是两种具体的方法。
transformer上手（7）—— 快速分词器
哦豁灬
04-15 5474
这里使用的是 IOB 标签格式，“B-XXX”表示某一种标签的开始，“I-XXX”表示某一种标签的中间，“O”表示非标签。从 pipeline 的输出结果可以看到，模型采用的是 IOB1 格式，因此“Sylvain”对应的 4 个 token “S”、“##yl”、“##va”和“##in”预测的标签都为“I-PER”。以前面介绍的 simple 合并策略为例，将连续的标签为“I-XXX”的多个 token 进行合并（或者以“B-XXX”开头，后面接多个“I-XXX”的 token 序列），直到遇到。
基于 word2vec TextRNN 的新闻文本分类
02-07 742
基于 word2vec TextRNN 的新闻文本分类
datawhale课程《transformers入门》笔记7：Transformers解析序列标注任务
qq_56591814的博客
08-26 2946
Transformers解析序列标注任务 本文主要来自datawhale的transformer教程4.2和天国之影学习笔记。 1 序列标注任务简介 序列标注可以看作时token级别的分类问题，为文本中的每一个token预测一个标签 token级别的分类任务： NER（Named-entity recognition 名词-实体识别）分辨出文本中的名词和实体（person人名, organization组织机构名, location地点名…） POS（Part-of-speech tagging词性标注
#位置编码 class TransformerEmbedding(nn.Module): def __init__(self, config): super().__init__() # hyper params self.vocab_size = config["vocab_size"] self.hidden_size = config["d_model"] # 词向量维度 self.pad_idx = config["pad_idx"] dropout_rate = config["dropout"] self.max_length = config["max_length"] # layers,设置padding_idx可以让pad的词向量全为0 self.word_embedding = nn.Embedding( self.vocab_size, self.hidden_size, padding_idx=self.pad_idx ) self.pos_embedding = nn.Embedding( self.max_length, self.hidden_size, _weight=self.get_positional_encoding( self.max_length, self.hidden_size ),# 位置编码，权重通过get_positional_encoding函数计算得到 ) self.pos_embedding.weight.requires_grad_(False) # 不更新位置编码的权重 self.dropout = nn.Dropout(dropout_rate) # 随机失活层 def get_word_embedding_weights(self): return self.word_embedding.weight # 计算位置信息 @classmethod def get_positional_encoding(self, max_length, hidden_size):#max_length是最大长度，hidden_size是embedding维度相等 # Compute the positional encodings once in log space. pe = torch.zeros(max_length, hidden_size) # 初始化位置编码 # .unsqueeze(1) 是将这个一维张量转换为二维张量，即将其形状从 (max_length,) 变为 (max_length, 1)。这个操作在张量的维度上增加了一个维度，使其从一维变为二维，第二维的大小为 1。 position = torch.arange(0, max_length).unsqueeze(1) # 位置信息,从0到max_length-1 div_term = torch.exp( torch.arange(0, hidden_size, 2) * -(torch.log(torch.Tensor([10000.0])) / hidden_size) )# 计算位置编码的权重,为了性能考量（是数学上的对数函数分解） pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) return pe def forward(self, input_ids): # input_ids: [batch_size, seq_len] seq_len = input_ids.shape[1] assert ( seq_len <= self.max_length ), f"input sequence length should no more than {self.max_length} but got {seq_len}" position_ids = torch.arange(seq_len, dtype=torch.long, device=input_ids.device) position_ids = position_ids.unsqueeze(0).expand_as(input_ids) print(position_ids) #为了调试 # embedding word_embeds = self.word_embedding(input_ids) # 词嵌入 pos_embeds = self.pos_embedding(position_ids) # 位置编码 embeds = word_embeds + pos_embeds embeds = self.dropout(embeds) return embeds def plot_position_embedding(position_embedding):# 绘制位置编码 plt.pcolormesh(position_embedding) # 绘制位置编码矩阵 plt.xlabel('Depth') plt.ylabel('Position') plt.colorbar() # 颜色条，-1到1的颜色范围 plt.show() position_embedding = TransformerEmbedding.get_positional_encoding(64, 128) plot_position_embedding(position_embedding)这段transformer代码添加注释，详细说一下代码什么意思
03-26
position_ids = position_ids.unsqueeze(0).expand_as(input_ids) # 形状变为 [batch_size, seq_len] # 计算词嵌入 + 位置编码 word_embeds = self.word_embedding(input_ids) # 词嵌入 [batch_size, seq_len, ...
def forward(self, input_ids): # input_ids: [batch_size, seq_len] seq_len = input_ids.shape[1] assert ( seq_len <= self.max_length ), f"input sequence length should no more than {self.max_length} but got {seq_len}" position_ids = torch.arange(seq_len, dtype=torch.long, device=input_ids.device) position_ids = position_ids.unsqueeze(0).expand_as(input_ids) print(position_ids) #为了调试 # embedding word_embeds = self.word_embedding(input_ids) # 词嵌入 pos_embeds = self.pos_embedding(position_ids) # 位置编码 embeds = word_embeds + pos_embeds embeds = self.dropout(embeds) return embeds这个transformer的向前传播方法具体做了哪些事情
03-27
position_ids = torch.arange(seq_len, dtype=torch.long, device=input_ids.device) position_ids = position_ids.unsqueeze(0).expand_as(input_ids) ``` - **步骤分解**： 1. **创建基础序列**：生成`[0, 1, 2, ...
from transformers import BertTokenizer, BertModel import torch from sklearn.metrics.pairwise import cosine_similarity # 加载BERT模型和分词器 tokenizer = BertTokenizer.from_pretrained('bert-base-chinese') model = BertModel.from_pretrained('bert-base-chinese') # 种子词列表 seed_words = ['个人信息', '隐私', '泄露', '安全'] # 加载微博用户文本语料（假设存储在weibo1.txt文件中） with open('output/weibo1.txt', 'r', encoding='utf-8') as f: corpus = f.readlines() # 预处理文本语料，获取每个中文词汇的词向量 corpus_vectors = [] for text in corpus: # 使用BERT分词器将文本分成词汇 tokens = tokenizer.tokenize(text) # 将词汇转换为对应的id input_ids = tokenizer.convert_tokens_to_ids(tokens) # 将id序列转换为PyTorch张量 input_ids = torch.tensor(input_ids).unsqueeze(0) # 使用BERT模型计算词向量 with torch.no_grad(): outputs = model(input_ids) last_hidden_state = outputs[0][:, 1:-1, :] avg_pooling = torch.mean(last_hidden_state, dim=1) corpus_vectors.append(avg_pooling.numpy()) # 计算每个中文词汇与种子词的余弦相似度 similarity_threshold = 0.8 privacy_words = set() for seed_word in seed_words: # 将种子词转换为对应的id seed_word_ids = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(seed_word)) # 将id序列转换为PyTorch张量，并增加batch size维度 seed_word_ids = torch.tensor(seed_word_ids).unsqueeze(0) # 使用BERT模型计算种子词的词向量 with torch.no_grad(): outputs = model(seed_word_ids) last_hidden_state = outputs[0][:, 1:-1, :] avg_pooling = torch.mean(last_hidden_state, dim=1) seed_word_vector = avg_pooling.numpy() # 计算每个中文词汇与种子词的余弦相似度 for i, vector in enumerate(corpus_vectors): sim = cosine_similarity([seed_word_vector], [vector])[0][0] if sim >= similarity_threshold: privacy_words.add(corpus[i]) print(privacy_words) 上述代码运行后报错了，报错信息：ValueError: Found array with dim 3. check_pairwise_arrays expected <= 2. 怎么修改？
05-31
seed_word_ids = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(seed_word)) # 将id序列转换为PyTorch张量，并增加batch size维度 seed_word_ids = torch.tensor(seed_word_ids).unsqueeze(0) # 使用...
import tkinter as tk from tkinter import ttk, scrolledtext, messagebox import subprocess import threading import re import time import os from datetime import datetime class DeviceManager: """设备管理类""" def __init__(self): self.devices = {} # {device_id: {'status': 'idle', 'session_id': None, 'last_test': None}} self.lock = threading.Lock() def refresh_devices(self): """刷新设备列表""" try: result = subprocess.run( ["adb", "devices"], capture_output=True, text=True, encoding="utf-8" ) new_devices = {} for line in result.stdout.splitlines()[1:]: if line.strip() and "device" in line: device_id = line.split("\t")[0] new_devices[device_id] = self.devices.get( device_id, {'status': 'idle', 'session_id': None, 'last_test': None} ) with self.lock: self.devices = new_devices return True except Exception as e: return False, str(e) def update_device_status(self, device_id, status, session_id=None): """更新设备状态""" with self.lock: if device_id in self.devices: self.devices[device_id]['status'] = status if session_id: self.devices[device_id]['session_id'] = session_id if status == 'completed': self.devices[device_id]['last_test'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") def get_selected_devices(self, selected_ids): """获取选中的设备信息""" with self.lock: return {did: info for did, info in self.devices.items() if did in selected_ids} class GMSTestAssistant(tk.Tk): def __init__(self): super().__init__() self.title("GMS测试助手 v3.0 - 多设备管理") self.geometry("1100x800") self.device_manager = DeviceManager() # 创建主框架 self.create_widgets() self.refresh_devices() # 测试状态 self.test_running = False self.active_threads = {} # 定时刷新设备状态 self.after(5000, self.periodic_refresh) def create_widgets(self): """创建界面组件""" # 设备管理面板 device_frame = ttk.LabelFrame(self, text="设备管理") device_frame.pack(fill="x", padx=15, pady=10) # 设备列表控件 self.device_tree = ttk.Treeview( device_frame, columns=("status", "session", "last_test"), show="headings", height=8 ) self.device_tree.heading("#0", text="设备ID") self.device_tree.heading("status", text="状态") self.device_tree.heading("session", text="Session ID") self.device_tree.heading("last_test", text="最后测试时间") self.device_tree.column("#0", width=200) self.device_tree.column("status", width=100) self.device_tree.column("session", width=150) self.device_tree.column("last_test", width=150) # 添加滚动条 scrollbar = ttk.Scrollbar(device_frame, orient="vertical", command=self.device_tree.yview) self.device_tree.configure(yscrollcommand=scrollbar.set) # 布局 self.device_tree.pack(side="left", fill="both", expand=True, padx=(0, 5)) scrollbar.pack(side="right", fill="y") # 设备操作按钮 btn_frame = ttk.Frame(device_frame) btn_frame.pack(side="right", fill="y", padx=5) ttk.Button(btn_frame, text="刷新设备", command=self.refresh_devices).pack(pady=5) ttk.Button(btn_frame, text="全选", command=self.select_all).pack(pady=5) ttk.Button(btn_frame, text="取消全选", command=self.deselect_all).pack(pady=5) # 测试控制面板 control_frame = ttk.LabelFrame(self, text="测试控制") control_frame.pack(fill="x", padx=15, pady=10) # 测试类型选择 test_type_frame = ttk.Frame(control_frame) test_type_frame.pack(fill="x", pady=5) self.test_type = tk.StringVar(value="full") ttk.Radiobutton(test_type_frame, text="完整测试", variable=self.test_type, value="full").pack(side="left", padx=10) ttk.Radiobutton(test_type_frame, text="单模块测试", variable=self.test_type, value="module").pack(side="left", padx=10) ttk.Radiobutton(test_type_frame, text="重测失败", variable=self.test_type, value="retry").pack(side="left", padx=10) # 测试参数输入 param_frame = ttk.Frame(control_frame) param_frame.pack(fill="x", pady=5) ttk.Label(param_frame, text="模块:").pack(side="left", padx=(5,0)) self.module_var = tk.StringVar() ttk.Entry(param_frame, textvariable=self.module_var, width=25).pack(side="left") ttk.Label(param_frame, text="测试项:").pack(side="left", padx=(10,0)) self.test_case_var = tk.StringVar() ttk.Entry(param_frame, textvariable=self.test_case_var, width=25).pack(side="left") ttk.Label(param_frame, text="重试次数:").pack(side="left", padx=(20,5)) self.retry_count_var = tk.IntVar(value=1) ttk.Spinbox(param_frame, from_=1, to=10, width=5, textvariable=self.retry_count_var).pack(side="left") # 执行按钮 ttk.Button(control_frame, text="执行测试", command=self.execute_tests, width=15).pack(pady=10) # 日志显示区域 log_frame = ttk.LabelFrame(self, text="测试日志") log_frame.pack(fill="both", expand=True, padx=15, pady=10) self.log_text = scrolledtext.ScrolledText( log_frame, wrap="word", font=("Consolas", 10), bg="#1e1e1e", fg="#d4d4d4" ) self.log_text.pack(fill="both", expand=True, padx=5, pady=5) # 状态栏 self.status_var = tk.StringVar(value="就绪") status_bar = ttk.Label(self, textvariable=self.status_var, relief="sunken") status_bar.pack(side="bottom", fill="x") def refresh_devices(self): """刷新设备列表""" self.log("刷新设备列表中...", "info") success, message = self.device_manager.refresh_devices() if not success: self.log(f"刷新设备失败: {message}", "error") return # 清空现有列表 for item in self.device_tree.get_children(): self.device_tree.delete(item) # 添加新设备 for device_id, info in self.device_manager.devices.items(): status = "空闲" if info['status'] == 'idle' else "测试中" session = info['session_id'] or "无" last_test = info['last_test'] or "从未测试" item = self.device_tree.insert( "", "end", text=device_id, values=(status, session, last_test), tags=(info['status'],) ) # 设置标签颜色 self.device_tree.tag_configure( 'idle', background='#d9ead3' # 空闲状态绿色 ) self.device_tree.tag_configure( 'testing', background='#fce5cd' # 测试中黄色 ) self.device_tree.tag_configure( 'completed', background='#c9daf8' # 完成状态蓝色 ) self.log(f"找到 {len(self.device_manager.devices)} 台设备", "success") def periodic_refresh(self): """定时刷新设备状态""" if not self.test_running: self.refresh_devices() self.after(5000, self.periodic_refresh) def select_all(self): """全选设备""" for item in self.device_tree.get_children(): self.device_tree.selection_add(item) def deselect_all(self): """取消全选""" self.device_tree.selection_set([]) def execute_tests(self): """执行测试""" selected_items = self.device_tree.selection() if not selected_items: self.log("错误: 请至少选择一个设备", "error") return # 获取选中的设备ID device_ids = [self.device_tree.item(item, "text") for item in selected_items] # 更新设备状态为测试中 for device_id in device_ids: self.device_manager.update_device_status(device_id, "testing") # 刷新设备列表显示 self.refresh_devices() # 根据测试类型执行 test_type = self.test_type.get() self.test_running = True self.status_var.set("测试执行中...") if test_type == "full": self.run_full_test(device_ids) elif test_type == "module": module = self.module_var.get().strip() if not module: self.log("错误: 请输入测试模块名称", "error") return test_case = self.test_case_var.get().strip() self.run_module_test(device_ids, module, test_case) elif test_type == "retry": retry_count = self.retry_count_var.get() self.retry_failed(device_ids, retry_count) def run_full_test(self, device_ids): """执行完整测试""" for device_id in device_ids: thread = threading.Thread( target=self._run_device_test, args=(device_id, "run cts --shard-count 3"), daemon=True ) self.active_threads[device_id] = thread thread.start() self.log(f"设备 {device_id} 开始完整测试", "info") def run_module_test(self, device_ids, module, test_case=None): """执行模块测试""" command = f"run cts -m {module}" if test_case: command += f" -t {test_case}" for device_id in device_ids: thread = threading.Thread( target=self._run_device_test, args=(device_id, command), daemon=True ) self.active_threads[device_id] = thread thread.start() self.log(f"设备 {device_id} 开始测试模块: {module}", "info") def retry_failed(self, device_ids, retry_count): """重试失败用例""" for device_id in device_ids: # 获取设备的上次Session ID session_id = self.device_manager.devices.get(device_id, {}).get('session_id') if not session_id: self.log(f"设备 {device_id} 无可用Session ID，跳过重试", "warning") continue for i in range(retry_count): thread = threading.Thread( target=self._run_device_test, args=(device_id, f"run retry --retry {session_id}"), daemon=True ) self.active_threads[device_id] = thread thread.start() self.log(f"设备 {device_id} 开始第 {i+1}/{retry_count} 次重试 (Session: {session_id})", "info") # 等待当前重试完成 while thread.is_alive(): time.sleep(1) def _run_device_test(self, device_id, command): """在设备上执行测试命令""" try: # 模拟测试执行过程 self.log(f"设备 {device_id}: 开始执行命令: {command}", "info") # 在实际应用中，这里应替换为真正的测试命令执行 # 例如: subprocess.run(f"adb -s {device_id} shell {command}", ...) # 模拟测试过程 for i in range(1, 11): if not self.test_running: break time.sleep(1) progress = i * 10 self.log(f"设备 {device_id}: 测试进度 {progress}%", "info") # 模拟捕获Session ID session_id = f"{device_id[:4]}-{int(time.time())}" self.device_manager.update_device_status(device_id, "completed", session_id) self.log(f"设备 {device_id} 测试完成! Session ID: {session_id}", "success") except Exception as e: self.log(f"设备 {device_id} 测试错误: {str(e)}", "error") self.device_manager.update_device_status(device_id, "idle") finally: # 从活动线程中移除 if device_id in self.active_threads: del self.active_threads[device_id] # 如果没有活动线程，标记测试完成 if not self.active_threads: self.test_running = False self.status_var.set("测试完成") # 刷新设备状态 self.refresh_devices() def log(self, message, level="info"): """添加带颜色编码的日志到文本框""" tag = level self.log_text.configure(state="normal") if level == "error": self.log_text.insert("end", message + "\n", "error") self.log_text.tag_config("error", foreground="#f48771") elif level == "success": self.log_text.insert("end", message + "\n", "success") self.log_text.tag_config("success", foreground="#6a9955") elif level == "warning": self.log_text.insert("end", message + "\n", "warning") self.log_text.tag_config("warning", foreground="#dcdcaa") else: self.log_text.insert("end", message + "\n", "info") self.log_text.tag_config("info", foreground="#d4d4d4") self.log_text.see("end") self.log_text.configure(state="disabled") self.update_idletasks() if __name__ == "__main__": app = GMSTestAssistant() app.mainloop()
07-30
device_ids.append(device_id) self.devices.append(device_id) self.root.after(0, self.update_device_list, device_ids) self.update_status(f"找到 {len(device_ids)} 台设备") except Exception as e: ...
基于bert的命名实体识别任务（一）
donruo的博客
02-23 8607
自从bert提出后，nlp领域的预训练语言模型持续刷新各种任务榜单，各种预训练语言模型不断提出并更新迭代，最新的GPT3以千亿级的参数再次刷新了榜单任务。但是在工业界，bert的预训练+微调的任务模式还是在发挥一定的作用。因此本篇博客主要介绍在tf2.x的版本下使用bert模型进行命名实体识别任务。 bert模型的原理还是先简单介绍一下，主要从一下几个方面： 一、任务目标 bert的目标是学习大量的没有标注的语料数据，进而提取出语言模型，便于下游的微调任务。在训练的过程中主要有两个任务：其一是根据上下
ELMo代码详解(一)：数据准备
刘伟的博客
06-28 1万+
ELMo代码解读笔记 1.数据准备   数据准备包括:1.生成word的词汇表类; 2.生成字符的词汇表类； 3.以word-ids作为输入的训练batch生成类; 4.以char-ids作为输入的训练batch生成类; 5.生成语言模型输入的数据集类 1.1 word词汇表类(Vocabulary)   根据一个词汇表文件，生成word和索引的相互对应关系，即_id_to_w...
BERT简单使用
热门推荐
百川的博客
01-03 2万+
文章目录Use BERT as feature环境入口最终结果预处理 Use BERT as feature 如何调用bert，将输入的语句输出为向量？ 如果在自己的代码中添加bert作为底层特征，需要官方例子run_classifier.py的那么多代码吗？ 环境 mac: tf==1.4.0 python=2.7 windows: tf==1.12 python=3.5 入口 调用预训...
脑机接口（BCI）常用开发语言全景分析：从信号处理到系统构建的技术选型指南
AllenLV的博客
11-23 443
本文系统分析了脑机接口（BCI）开发中的主流编程语言生态。Python凭借丰富的科学计算库成为算法开发的首选；MATLAB以其专业工具箱在科研领域占据优势；C/C++凭借高性能特性在实时处理和硬件交互中发挥关键作用；Java则擅长跨平台应用开发与系统集成。这些语言各具优势，在不同技术环节协同配合，共同推动BCI技术的发展。文章为开发者提供了全面的技术选型参考，有助于根据具体应用场景选择最合适的编程语言组合。
基于GEC6818平台的五子棋人机对战系统设计与实现
11-25
五子棋作为一种广为人知的策略性棋盘游戏，其基本规则易于掌握。在选定人机对战模式后，由程序执黑先行，用户执白应对。双方依次在棋盘上落子，任何一方在横向、纵向或斜向形成连续五个或更多同色棋子即获胜。 项目资源涵盖多个技术领域的程序代码，涉及前后端开发、移动终端应用、操作系统、智能系统、物联网技术、信息管理系统、数据存储方案、硬件设计、大数据处理、教学资料、多媒体处理及网站构建等多个方向。具体技术实例包括嵌入式平台如STM32与ESP8266，编程语言如PHP、QT、C++、Java、Python、C#，系统开发如Linux与iOS，以及电子设计自动化工具和实时操作系统等。 主要技术栈包含服务端开发语言Java、Python及Node.js，后端框架Spring Boot与Django，前端技术React、Angular与Vue，界面设计框架Bootstrap与Material-UI，数据库系统MySQL、PostgreSQL和MongoDB，缓存工具Redis，以及容器化部署方案Docker与Kubernetes。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
lv_0_20251125195629.mp4
11-25
lv_0_20251125195629.mp4
numpy、pandas、sklearn、pytorch等数据分析工具的一些使用技巧
11-25
NumPy数组操作实战技巧 numpy、pandas、sklearn、pytorch等数据分析工具的一些使用技巧
中国Cassandra数据库用户组开源社区项目-专注于Apache-Cassandra分布式NoSQL数据库技术研究与实践-提供技术文档下载与源码解析-集成Titan图数据库与Lu.zip
最新发布
11-25
Buffer内存管理实战技巧中国Cassandra数据库用户组开源社区项目_专注于Apache_Cassandra分布式NoSQL数据库技术研究与实践_提供技术文档下载与源码解析_集成Titan图数据库与Lu.zip中国Cassandra数据库用户组开源社区项目_专注于Apache_Cassandra分布式NoSQL数据库技术研究与实践_提供技术文档下载与源码解析_集成Titan图数据库与Lu.zip
图像处理基于电磁学优化算法的多阈值分割算法研究（Matlab代码实现）
11-25
【图像处理】基于电磁学优化算法的多阈值分割算法研究（Matlab代码实现）内容概要：本文研究基于电磁学优化算法（Electromagnetism-like Optimization, EMO）的多阈值图像分割方法，并通过Matlab代码实现。该方法借鉴电磁学中电荷间相互作用的机制，将图像分割问题转化为优化问题，利用EMO算法搜索最优阈值组合，以最大化分割效果的评价指标（如Otsu法或多级别熵）。文中详细介绍了EMO算法的基本原理、实现步骤及其在图像多阈值分割中的具体应用流程，展示了该算法能够有效避免传统方法易陷入局部最优的问题，从而获得更精确的分割结果。; 适合人群：具备图像处理基础知识和Matlab编程能力的高校学生、科研人员及工程技术人员。; 使用场景及目标：①解决复杂背景下图像的多目标分割问题，提升医学影像、遥感图像等领域的分割精度；②学习智能优化算法（如EMO）在图像处理中的实际应用，为研究新型分割算法提供技术参考和实现范例。; 阅读建议：在学习过程中应结合Matlab代码，深入理解EMO算法的寻优机制与图像分割评价函数的构建方法，建议自行调试不同参数对分割效果的影响，以加深对算法性能的理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值