【C++】unordered_set和unordered_map

news2024/11/26 2:47:47

底层哈希结构

namespace hash_bucket
{
	template<class T>
	struct HashData
	{
		T _data;
		struct HashData* next = nullptr;
		HashData(const T& data)
			:_data(data)
		{}
	};

	//仿函数:这里直接用开散列仿函数
	template <class K>
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};
	template <>
	struct HashFunc<string>//特化
	{
		size_t operator()(const string& key)
		{
			size_t res = 0;
			for (auto e : key)
			{
				res *= 131;
				res += e;
			}
			return res;
		}
	};

	//迭代器
	//前置声明
	template<class K, class T, class Hash, class KeyOfT>
	class HashTable;

	template<class K, class T, class Hash, class KeyOfT>
	struct _HashTableIterator
	{
		typedef HashData<T> Node;
		typedef HashTable<K, T, Hash, KeyOfT> Ht;
		typedef _HashTableIterator<K, T, Hash, KeyOfT> Self;

		Node* _node;
		Ht* _pht;

		_HashTableIterator(Node* node,Ht* pht)
			:_node(node)
			,_pht(pht){}
		T& operator*()
		{
			return _node->_data;
		}
		T* operator->()
		{
			return &_node->_data;
		}
		Self& operator++()
		{
			if (_node->next)
			{
				//当前桶
				_node = _node->next;
			}
			else
			{
				//下一个桶
				KeyOfT kot;
				Hash hash;
				size_t i = hash(kot(_node->_data)) % _pht->_size;
				for (++i; i < _pht->_tables.size(); i++)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						if(node)
							break;
					}
				}
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}
		bool operator!=(Self& s)const
		{
			return s._node != _node;
		}
		bool operator==(Self& s)const
		{
			return !operator!=(s);
		}
	};

	template<class K, class T, class Hash, class KeyOfT>
	class HashTable
	{
		typedef HashData<T> Node;
		typedef _HashTableIterator<K, T, Hash, KeyOfT> iterator;
	public:
		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i] != nullptr)
					return iterator(_tables[i], this);
			}
			return end();
		}
		iterator end()
		{
			return iterator(nullptr, this);
		}
	public:
		HashTable()
			:_size(0)
			,_tables(10, nullptr)
		{}
		~HashTable()//这里的析构函数得自己添加，否则只会析构哈希表，导致节点数据没有被释放
		{
			//这里的操作和底下的打印有点像
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		bool Insert(const T& data)
		{
			Hash hash;
			KeyOfT kot;

			if (Find(kot(data)))
				return false;

			//负载因子到 1 就扩容
			if (_size == _tables.size())//扩容
			{
				size_t newSize = _tables.size() * 2;
				vector<Node*> newTables(newSize, nullptr);
				size_t hashi = 0;
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->next;
						hashi = hash(kot(cur->_data)) % newTables.size();
						cur->next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}

			size_t hashi = hash(kot(data)) % _tables.size();
			//头插
			Node* old = _tables[hashi];
			_tables[hashi] = new Node(data);
			_tables[hashi]->next = old;
			_size++;
			return true;
		}
		Node* Find(const K& key)
		{
			if (_size == 0)
				return nullptr;

			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = nullptr;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				cur = _tables[i];
				while (cur)
				{
					if (kot(cur->_data) == key)
					{
						return cur;
					}
					cur = cur->next;
				}
			}
			return nullptr;
		}
		void Print()
		{
			KeyOfT kot;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					cout << "[" << kot(cur->_data) << ": " << kot(cur->_data) << "]-->";
					cur = cur->next;
				}
			}
			cout << endl;
		}
		bool Erase(const K& key)
		{
			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev)
					{
						prev->next = cur->next;
					}
					else
					{
						_tables[hashi] = cur->next;

					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->next;
				}
			}
			return false;
		}
		size_t size()
		{
			return _size;
		}
	private:
		size_t _size = 0;//有效数据个数
		vector<Node*> _tables;
	};
}

unordered_set

namespace hash_bucket
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	private:
		HashTable<K, K,Hash,SetKeyOfT> _ht;
	public:
		typedef  typename HashTable<K, K, Hash, SetKeyOfT> ::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		bool insert(const K& Node)
		{
			return _ht.Insert(Node);
		}
	};
	void unorderedset_test1()
	{
		unordered_set<int> s;

		s.insert(2);
		s.insert(4);
		s.insert(9);
		s.insert(1);
		s.insert(2);
		s.insert(3);

		for (auto e : s)
		{
			cout << e << " ";
		}
	}
}

unordered_map

namespace hash_bucket
{
	template<class K,class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& key)
			{
				return key.first;
			}
		};
	private:
		HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht;
	public:
		typedef  typename HashTable<K, pair<K, V>, Hash, MapKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		bool insert(const pair<K, V>& Node)
		{
			return _ht.Insert(Node);
		}
	};
	void unorderedmap_test1()
	{
		unordered_map<string, string> dict;
		dict.insert(make_pair("insert", "插入"));
		dict.insert(make_pair("sort" , "排序"));
		dict.insert(make_pair("delete", "删除"));
		dict.insert(make_pair("string", "字符串"));
		dict.insert(make_pair("iterator", "迭代器"));
		unordered_map<string, string>::iterator umit = dict.begin();
		//while (umit != dict.end())
		//{
		//	cout << umit->first << ":" << umit->second << endl;
		//	++umit;
		//}
		//cout << endl;
	}
}

此时编译：
在这里插入图片描述报错！
HashTable和其迭代器互相调用
从逻辑上讲，HashTable应该给迭代器开放权限，如下设置一个友元类即可
在这里插入图片描述
因为是模板故必须带参数。
经检测，以上代码有个小bug，可能会导致数据打印时无法跳出迭代器，形成死循环打印；
提示：错误点在该段代码中

		Self& operator++()
		{
			if (_node->next)
			{
				//当前桶
				_node = _node->next;
			}
			else
			{
				//下一个桶
				KeyOfT kot;
				Hash hash;
				size_t i = hash(kot(_node->_data)) % _pht->_size;
				for (++i; i < _pht->_tables.size(); i++)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						if(node)
							break;
					}
				}
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}

在这里插入图片描述
在这里我们是不是应该对哈希表的大小取模，而不是对现在的有效数据个数取模

size_t i = hash(kot(_node->_data)) % _pht->_tables.size();

完整代码

代码实现标准化，实现[ ]重载

#pragma once
#include "hash.h"
namespace hash_bucket
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	private:
		HashTable<K, K,Hash,SetKeyOfT> _ht;
	public:
		typedef  typename HashTable<K, K, Hash, SetKeyOfT> ::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		pair<iterator, bool> insert(const K& Node)
		{
			return _ht.Insert(Node);
		}
	};
	void unorderedset_test1()
	{
		unordered_set<int> s;

		s.insert(2);
		s.insert(4);
		s.insert(9);
		s.insert(1);
		s.insert(2);
		s.insert(3);

		for (auto e : s)
		{
			cout << e << " ";
		}
	}
}

#pragma once
#include "hash.h"
namespace hash_bucket
{
	template<class K,class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& key)
			{
				return key.first;
			}
		};
	private:
		HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht;
	public:
		typedef  typename HashTable<K, pair<K, V>, Hash, MapKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		pair<iterator,bool> insert(const pair<K, V>& Node)
		{
			return _ht.Insert(Node);
		}
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}
	};
	void unorderedmap_test1()
	{
		unordered_map<string, string> dict;
		dict.insert(make_pair("insert", "插入"));
		dict.insert(make_pair("sort" , "排序"));
		dict.insert(make_pair("delete", "删除"));
		dict.insert(make_pair("string", "字符串"));
		dict.insert(make_pair("iterator", "迭代器"));
		unordered_map<string, string>::iterator umit = dict.begin();
		while (umit != dict.end())
		{
			cout << umit->first << ":" << umit->second << endl;
			++umit;
		}
		cout << endl;
	}
	void unorderedmap_test2()
	{
		string arr[] = { "梨子","苹果","猕猴桃","桃" ,"梨子","苹果", "猕猴桃","猕猴桃","猕猴桃","梨子","猕猴桃" };
		unordered_map<string, int> countMap;
		for (const auto& str : arr)
		{
			countMap[str]++;
		}
		unordered_map<string, int>::iterator it = countMap.begin();
		while (it != countMap.end())
		{
			cout << (*it).first << ":" << (*it).second << endl;
			++it;
		}
		cout << endl << endl;
		for (auto e : countMap)
		{
			cout << e.first << ":" << e.second << endl;
		}
		cout << endl;
	}
}

namespace hash_bucket
{
	template<class T>
	struct HashData
	{
		T _data;
		struct HashData* next = nullptr;
		HashData(const T& data)
			:_data(data)
		{}
	};

	//仿函数:这里直接用开散列仿函数
	template <class K>
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};
	template <>
	struct HashFunc<string>//特化
	{
		size_t operator()(const string& key)
		{
			size_t res = 0;
			for (auto e : key)
			{
				res *= 131;
				res += e;
			}
			return res;
		}
	};

	//迭代器
	//前置声明
	template<class K, class T, class Hash, class KeyOfT>
	class HashTable;

	template<class K, class T, class Hash, class KeyOfT>
	struct _HashTableIterator
	{
		typedef HashData<T> Node;
		typedef HashTable<K, T, Hash, KeyOfT> Ht;
		typedef _HashTableIterator<K, T, Hash, KeyOfT> Self;

		Node* _node;
		Ht* _pht;

		_HashTableIterator(Node* node,Ht* pht)
			:_node(node)
			,_pht(pht){}
		T& operator*()
		{
			return _node->_data;
		}
		T* operator->()
		{
			return &_node->_data;
		}
		Self& operator++()
		{
			if (_node->next)
			{
				//当前桶
				_node = _node->next;
			}
			else
			{
				//下一个桶
				KeyOfT kot;
				Hash hash;
				size_t i = hash(kot(_node->_data)) % _pht->_tables.size();
				for (++i; i < _pht->_tables.size(); i++)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						if (_node)
						{
							break;
						}
					}
				}
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}
		Self& operator++(int)
		{
			Self tmp = this;
			if (_node->next)
			{
				//当前桶
				_node = _node->next;
			}
			else
			{
				//下一个桶
				KeyOfT kot;
				Hash hash;
				size_t i = hash(kot(_node->_data)) % _pht->size();
				for (++i; i < _pht->_tables.size(); i++)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						break;
					}
				}
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return tmp;
		}
		bool operator!=(const Self& s) const
		{
			return s._node != _node;
		}
		bool operator==(const Self& s) const
		{
			return s._node == _node;
		}
	};

	template<class K, class T, class Hash, class KeyOfT>
	class HashTable
	{
		template<class K, class T, class Hash, class KeyOfT>
		friend struct _HashTableIterator;
		typedef HashData<T> Node;
	public:
		typedef _HashTableIterator<K, T, Hash, KeyOfT> iterator;
		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i] != nullptr)
					return iterator(_tables[i], this);
			}
			return end();
		}
		iterator end()
		{
			return iterator(nullptr, this);
		}
	public:
		HashTable()
			:_size(0)
			,_tables(10, nullptr)
		{}
		~HashTable()//这里的析构函数得自己添加，否则只会析构哈希表，导致节点数据没有被释放
		{
			//这里的操作和底下的打印有点像
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		pair<iterator,bool> Insert(const T& data)
		{
			Hash hash;
			KeyOfT kot;

			iterator ret = Find(kot(data));
			if (ret != end())
				return make_pair(ret, false); 

			//负载因子到 1 就扩容
			if (_size == _tables.size())//扩容
			{
				size_t newSize = _tables.size() * 2;
				vector<Node*> newTables(newSize, nullptr);
				//这里为了减少调用，不像开散列那样采用复用insert的形式，而是直接将原表中的节点拿下来直接用
				//而且复用insert的时候会涉及空间的申请释放问题（申请新节点，将旧节点的值给新节点，然后释放新旧结点）
				size_t hashi = 0;
				//旧表数据移到新表
				//特别注意：一个一个数据移动，不可一串一串移动，那样的话会造成映射位置错误，最后使其数据不能被正常找到
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->next;
						hashi = hash(kot(cur->_data)) % newTables.size();
						cur->next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}

			size_t hashi = hash(kot(data)) % _tables.size();
			//头插
			Node* old = _tables[hashi];
			_tables[hashi] = new Node(data);
			_tables[hashi]->next = old;
			_size++;
			return make_pair(iterator(_tables[hashi], this), true);
		}
		iterator Find(const K& key)
		{
			if (_size == 0)
				return iterator(nullptr, this);

			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = nullptr;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				cur = _tables[i];
				while (cur)
				{
					if (kot(cur->_data) == key)
					{
						return iterator(cur, this);
					}
					cur = cur->next;
				}
			}
			return end();
		}
		void Print()
		{
			KeyOfT kot;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					cout << "[" << kot(cur->_data) << ": " << kot(cur->_data) << "]-->";
					cur = cur->next;
				}
			}
			cout << endl;
		}
		bool Erase(const K& key)
		{
			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev)
					{
						prev->next = cur->next;
					}
					else
					{
						_tables[hashi] = cur->next;

					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->next;
				}
			}
			return false;
		}
		size_t size()
		{
			return _size;
		}
	private:
		size_t _size = 0;//有效数据个数
		vector<Node*> _tables;
	};
}

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

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

相关文章

attention and tell论文【无标题】

attention and tell论文【无标题】

这个公式使用LaTeX语法表示为&#xff1a; ( i t f t o t c t ) ( σ σ σ tanh ⁡ ) T D m n , n ( E y t − 1 h t − 1 x t ) \begin{pmatrix}i_t \\f_t \\o_t \\c_t\end{pmatrix} \begin{pmatrix}\sigma \\\sigma \\\sigma \\\tanh\end{pmatrix}T_{Dmn,n}\begin{pmatri…
阅读更多...
HackMyVM-Gift

HackMyVM-Gift

目录 信息收集 arp nmap WEB dirsearch hydra ssh连接 get root 信息收集 arp ┌─[rootparrot]─[~] └──╼ #arp-scan -l Interface: enp0s3, type: EN10MB, MAC: 08:00:27:16:3d:f8, IPv4: 192.168.9.102 Starting arp-scan 1.10.0 with 256 hosts (https://git…
阅读更多...
动态规划算法求解最长公共子序列

动态规划算法求解最长公共子序列

动态规划算法是运筹学中求解多阶段决策问题的经典算法&#xff0c;本文将介绍动态规划算法的基本思想&#xff0c;并介绍如何使用动态规划算法求解最长公共子序列问题。 1. 动态规划算法的基本思想 动态规划算法本质也是基于分治思想&#xff0c;将待求解问题分解成若干个子问…
阅读更多...
「GO基础」目录

「GO基础」目录

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:「stormsha的主页」…
阅读更多...
02_JavaWeb中的Tomcat（详解）

02_JavaWeb中的Tomcat（详解）

文章目录 Tomcat1, 概述1.1 安装1.2 目录结构1.3 启动/停止 2, 资源部署2.1 直接部署: 主要和重要的方式2.2 虚拟映射: 重要2.2.1 方式一:2.2.1 方式二: 2.3 原理解析 3, Tomcat组件3.1 Connector3.2 Engine3.2.1 Host3.2.1.1 Context 4, 其它: 重要4.1 设置 Tomcat 1, 概述 w…
阅读更多...
（踩坑）Please refer to 异常和Error creating bean with name 异常

（踩坑）Please refer to 异常和Error creating bean with name 异常

一、Please refer to 异常 如图所示&#xff0c;在使用maven构建项目的时候&#xff0c;如果提示该错误&#xff0c;则可能是xml配置文件有问题或者测试类等。但是没有明确的异常信息&#xff0c;所以做以下小改动&#xff0c;可以查看异常信息。 在IDEA工具中&#xff0c;打…
阅读更多...
08 SQL进阶 -- 集合运算 -- 表的连结（JOIN）

08 SQL进阶 -- 集合运算 -- 表的连结（JOIN）

1. 连结（JOIN） 前一节我们学习了 UNION和INTERSECT 等集合运算, 这些集合运算的特征就是以行方向为单位进行操作. 通俗地说, 就是进行这些集合运算时, 会导致记录行数的增减。使用 UNION 会增加记录行数,而使用 INTERSECT 或者 EXCEPT 会减少记录行数。 但这些运算不能改变…
阅读更多...
【Java开发指南 | 第十篇】Java修饰符

【Java开发指南 | 第十篇】Java修饰符

读者可订阅专栏&#xff1a;Java开发指南 |【CSDN秋说】 文章目录 JAVA修饰符访问修饰符非访问修饰符static 修饰符final 修饰符abstract 修饰符synchronized 修饰符transient 修饰符volatile 修饰符 JAVA修饰符 修饰符用来定义类、方法或者变量&#xff0c;通常放在语句的最前…
阅读更多...
2024年【高处安装、维护、拆除】考试题库及高处安装、维护、拆除复审模拟考试

2024年【高处安装、维护、拆除】考试题库及高处安装、维护、拆除复审模拟考试

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 高处安装、维护、拆除考试题库是安全生产模拟考试一点通生成的&#xff0c;高处安装、维护、拆除证模拟考试题库是根据高处安装、维护、拆除最新版教材汇编出高处安装、维护、拆除仿真模拟考试。2024年【高处安装、维…
阅读更多...
瞬态瑞丽波频散曲线提取

瞬态瑞丽波频散曲线提取

频散曲线 function [Y1, f, phase] = das_fft(signal1, signal2, Ts) [y, lag
阅读更多...
windows编译xlnt,获取Excel表里的数据

windows编译xlnt,获取Excel表里的数据

用git拉取项目 这个文件是空的 要用git拉下来&#xff0c;使用终端编译xlnt库 点击解决方案 运行生成 然后新建项目&#xff0c;配置好库&#xff0c; #include <iostream> #include <xlnt/xlnt.hpp>int main() {// 打开 Excel 文件xlnt::workbook workbook;workb…
阅读更多...
Ubuntu Vs code配置ROS开发环境

Ubuntu Vs code配置ROS开发环境

文章目录 1.开发环境2.集成开发环境搭建2.1 安装Ros2.2 安装 Vs code2.3 安装vs code 插件 3.Vs code 配置ROS3.1 创建ROS工作空间3.2 从文件夹启动Vs code3.3 使用Vscode 编译ROS 空间3.4 使用Vs code 创建功能包 4.编写简单Demo实例4.1编写代码4.2编译与执行 1.开发环境 系统…
阅读更多...
【数学】主成分分析（PCA）的应用案例（Python）

【数学】主成分分析（PCA）的应用案例（Python）

接着上篇PCA推导过程文章&#xff0c;本文结合图像来展示PCA的应用过程 Jupyter notebook 源文件在这里 1 借助库函数来PCA重建 使用sklearn库函数 # Import needed libs import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import load_digits from…
阅读更多...
大模型微调的几种常见方法

大模型微调的几种常见方法

在文章深入理解大语言模型微调技术中&#xff0c;我们详细了解大语言模型微调的概念和训练过程&#xff0c;本篇给大家介绍大模型微调常见的7种训练方法。 1、Adapter Tuning 2019年谷歌的研究人员首次在论文《Parameter-Efficient Transfer Learning for NLP》提出针对 BERT 的…
阅读更多...
java线程（1）

java线程（1）

1、多线程启动 有两种启动方式 1、实现Runable接口 2、继承Thread类并且重写run&#xff08;&#xff09;方法 在执行进程中的任务才会产生线程&#xff0c;所以需要实现Runable接口并且重写run&#xff08;&#xff09;方法&#xff0c;然后将Runable的实现对象作为参数传…
阅读更多...
(文章复现)分布式电源选址定容的多目标优化算法

(文章复现)分布式电源选址定容的多目标优化算法

参考文献&#xff1a; [1]夏澍,周明,李庚银.分布式电源选址定容的多目标优化算法[J].电网技术,2011,35(09):115-121. [2] Ye Tian, Ran Cheng, Xingyi Zhang, and Yaochu Jin, “PlatEMO: A MATLAB platform for evolutionary multi-objective optimization [educational for…
阅读更多...
图像处理与视觉感知---期末复习重点（8）

图像处理与视觉感知---期末复习重点（8）

文章目录 一、图像分类流程二、梯度方向直方图2.1 概述2.2 计算梯度方向直方图2.2.1 过程2.2.2 总结 三、SIFT 一、图像分类流程 流程&#xff1a;输入图像、预处理、特征提取、学习算法、类标。 二、梯度方向直方图 2.1 概述 1. 梯度方向直方图(Histogram of Oriented Gradie…
阅读更多...
【1688电商运营必看】掌握这些关键数据指标，轻松提升业绩！

【1688电商运营必看】掌握这些关键数据指标，轻松提升业绩！

1688电商运营&#xff0c;数据分析环节中需要关注多个关键指标&#xff0c;以便全面、深入地了解店铺或产品的运营状况。以下是一些主要的指标&#xff1a; 1、流量指标 访客数&#xff1a;反映店铺的吸引力和流量规模。 浏览量&#xff1a;显示页面的受欢迎程度&#xff0c…
阅读更多...
【AI开发：语言】二、Qwen1.5-7B模型本地部署CPU和GPU版

【AI开发：语言】二、Qwen1.5-7B模型本地部署CPU和GPU版

前言 之前文章&#xff0c;我们采用了Koblod运行Yi-34B大模型&#xff0c;本文采用LM Studio来运行千问模型。 LM Studio并没有开源&#xff0c;但是可以免费使用&#xff0c;他是目前本地进行模型测试最好的工具了。 在这里&#xff0c;依然使用Windows 10进行部署和测试&…
阅读更多...
GPT-3：NLP领域的革新者

GPT-3：NLP领域的革新者

在自然语言处理&#xff08;NLP&#xff09;领域&#xff0c;预训练模型一直是研究的热点。随着技术的不断进步&#xff0c;我们见证了从BERT到GPT等一系列模型的涌现。其中&#xff0c;GPT-3&#xff08;Generative Pre-trained Transformer 3&#xff09;以其卓越的生成能力和…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023