【备忘录】一些记不住的东西

置顶梅津太郎

已于 2023-05-17 08:30:38 修改

阅读量318

点赞数

分类专栏：杂烩文章标签： pytorch 深度学习 python

于 2022-11-20 18:23:13 首次发布

本文链接：https://blog.csdn.net/gaocui883/article/details/127952061

版权

杂烩专栏收录该内容

30 篇文章 1 订阅

订阅专栏

备忘录

2022.11.20日

pytorch 不安装cuda,cudnn 方法：

建立虚拟环境：

conda create -n xx python=3.8
conda remove -n xxx --all

pip3 install torch==1.8.2 torchvision==0.9.2 torchaudio==0.8.2 --extra-index-url https://download.pytorch.org/whl/lts/1.8/cu111

pip install torch==1.7.1+cu101 torchvision==0.8.2+cu101 torchaudio==0.7.2 -f https://download.pytorch.org/whl/torch_stable.html

日语系统的更改

在这里插入图片描述
2022.11.22 日

class initial(object):
    def __init__(self, f1 = 222):
        self.f1 = f1

    def pri(self):
        print("hello, F1 :", self.f1)


class new(initial):
    def __init__(self):
        print("this print is for new function. ")
        self.f1 = 33
        print('before the super function : ', self.f1)

        #
        super(new, self).__init__()

        print('after the super function : ', self.f1)

if __name__ == '__main__':
    new()
# before the super function :  33
# after the super function :  222

算法模板

并查集

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))  # 初始化，每个元素的父节点都是它本身
        self.rank = [0] * n           # 初始化，每个元素的秩都为0
        
    def find(self, x):
        if x != self.parent[x]:  # 如果x不是根节点，就一直往上找
            self.parent[x] = self.find(self.parent[x])  # 路径压缩
        return self.parent[x]
    
    def union(self, x, y):
        root_x, root_y = self.find(x), self.find(y)
        if root_x != root_y:  # 如果两个元素不在同一个集合中，就进行合并
            if self.rank[root_x] > self.rank[root_y]:  # 以秩小的为子节点，秩大的为父节点
                self.parent[root_y] = root_x
            elif self.rank[root_x] < self.rank[root_y]:
                self.parent[root_x] = root_y
            else:  # 如果秩相等，则随便选一个作为父节点，并把秩加1
                self.parent[root_y] = root_x
                self.rank[root_x] += 1

拓扑排序模板

from collections import deque

def topo_sort(graph):
    # 统计每个节点的入度
    in_degrees = {node: 0 for node in graph}
    for node in graph:
        for neighbor in graph[node]:
            in_degrees[neighbor] += 1

    # 将入度为 0 的节点加入队列
    queue = deque([node for node in graph if in_degrees[node] == 0])

    # 依次取出队列中的节点，并将其邻居的入度减 1
    result = []
    while queue:
        node = queue.popleft()
        result.append(node)
        for neighbor in graph[node]:
            in_degrees[neighbor] -= 1
            if in_degrees[neighbor] == 0:
                queue.append(neighbor)

    # 如果图中有环，则无法完成拓扑排序
    if len(result) != len(graph):
        return None
    else:
        return result

两个字符串的公共最长子序列

dp = [["" for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if str1[i-1] == str2[j-1]:
                    dp[i][j] = dp[i-1][j-1] + str1[i-1]
                else:
                    if len(dp[i-1][j]) > len(dp[i][j-1]):
                        dp[i][j] = dp[i-1][j]
                    else:
                        dp[i][j] = dp[i][j-1]
        LCS = dp[m][n]

桶排序

def bucket_sort(arr):
    # 找到最大值和最小值
    max_val, min_val = max(arr), min(arr)
    
    # 桶的数量和范围
    bucket_range = (max_val - min_val) / len(arr)
    bucket_size = len(arr) + 1
    
    # 创建桶
    buckets = [[] for _ in range(bucket_size)]
    
    # 将元素放入桶中
    for num in arr:
        index = int((num - min_val) / bucket_range)
        buckets[index].append(num)
        
    # 对每个桶进行排序
    for bucket in buckets:
        bucket.sort()
    
    # 将桶中的元素按顺序合并起来
    sorted_arr = []
    for bucket in buckets:
        sorted_arr.extend(bucket)
        
    return sorted_arr

01 背包模板

def test_2_wei_bag_problem1(bag_size, weight, value) -> int:
	rows, cols = len(weight), bag_size + 1
	dp = [[0 for _ in range(cols)] for _ in range(rows)]

	# 初始化dp数组.
	for i in range(rows):
		dp[i][0] = 0
	first_item_weight, first_item_value = weight[0], value[0]
	for j in range(1, cols):
		if first_item_weight <= j:
			dp[0][j] = first_item_value

	# 更新dp数组: 先遍历物品, 再遍历背包.
	for i in range(1, len(weight)):
		cur_weight, cur_val = weight[i], value[i]
		for j in range(1, cols):
			if cur_weight > j: # 说明背包装不下当前物品.
				dp[i][j] = dp[i - 1][j] # 所以不装当前物品.
			else:
				# 定义dp数组: dp[i][j] 前i个物品里，放进容量为j的背包，价值总和最大是多少。
				dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - cur_weight]+ cur_val)

	print(dp)


if __name__ == "__main__":
	bag_size = 4
	weight = [1, 3, 4]
	value = [15, 20, 30]
	test_2_wei_bag_problem1(bag_size, weight, value)

区间DP 问题

方法1：

for (int i = n; i >= 1; --i) {
	for (int j = i + 1; j <= n; ++j) {
		for (int k = i; k < j; ++k) {
			dp[i,j] = max/min(dp[i,j], dp[i,k] + dp[k+1, j] + cost)
		}
	}
}

方法2 ：

for (int len = 2; len <= n; ++len) {
	for (int i = 1; i + len - 1  <= n; ++i) {
		int j = i + len - 1;
		for (int k = i; k < j; ++k) {
			dp[i,j] = max/min(dp[i,j], dp[i,k] + dp[k+1, j] + cost)
		}
	}
}

单调栈模板

def monotonic_stack(arr):
    stack = []
    result = []
    for i in range(len(arr)):
        while stack and stack[-1] < arr[i]:
            stack.pop()
        stack.append(arr[i])
        result.append(stack[0]) # 根据具体题目需求修改结果

    return result

其中，arr是需要处理的序列，stack是维护单调栈的栈，result是结果数组。

在单调栈中，通常需要维护一个单调递增或单调递减的栈。当新元素进入栈时，如果该元素比栈顶元素大（或小），则一直弹出栈顶元素，直到栈为空或新元素比栈顶元素小（或大），此时将新元素压入栈中。

单调栈通常用于处理一些求解 “下一个更大元素”、“下一个更小元素” 等问题。具体实现时，可以根据问题的具体要求，修改代码中的 result.append() 语句。

论文工具

在这里插入图片描述

jupyter notebook 显示多个kernel

conda activate my-conda-env    # this is the environment for your project and code
conda install ipykernel
conda deactivate

conda activate base      # could be also some other environment
conda install nb_conda_kernels
jupyter notebook

只要在每个环境中安装ipykernel，然后再基础环境中安装 nb_conda_kernels 即可。

自动补全

安装 nbextensions
安装：pip install jupyter_contrib_nbextensions -i https://pypi.mirrors.ustc.edu.cn/simple
激活：jupyter contrib nbextension install --user

安装 nbextensions_configurator
安装：pip install jupyter_nbextensions_configurator
激活：jupyter nbextensions_configurator enable --user

风格

pip install jupyterthemes

jt -t onedork
jt -t grade3 -fs 13 # 最适合
其他的命令：https://www.cnblogs.com/ikventure/p/15192158.html

jupter lab 安装：
pip install jupyterlab

代码补全：
pip install jupyter-lsp
pip install python-lsp-server[all]
启动jupyter lab，在插件中搜索lsp，点击@krassowski/jupyterlab-lsp下的install安装 
setting 按钮 开启自动提示（Hinterland mode）

代码格式化：
$ pip install jupyterlab_code_formatter black isort