2023 “华为杯” 中国研究生数学建模竞赛(B题)深度剖析|数学建模完整代码+建模过程全解全析
华为杯数学建模B题
当大家面临着复杂的数学建模问题时,你是否曾经感到茫然无措?作为2021年美国大学生数学建模比赛的O奖得主,我为大家提供了一套优秀的解题思路,让你轻松应对各种难题。
让我们来看看研赛的B题呀~!
问题重述
DFT在通信等领域的重要应用,以及目前采用FFT计算DFT的硬件开销大的问题。提出了将DFT矩阵分解为整数矩阵乘积逼近的方法来降低硬件复杂度。
建模目标是对给定的DFT矩阵 F N F_N FN,找到一组K个矩阵A,使 F N F_N FN和A的乘积在Frobenius范数意义下尽可能接近,即最小化目标函数RMSE。
硬件复杂度C的计算公式给出,与矩阵A中元素的取值范围q和复数乘法次数L相关。
给出了两种约束条件。约束1限制A中每个矩阵的每行最多2个非零元素。约束2限制A中每个矩阵的元素取值范围为整数集P。
对DFT大小 N = 2 t , t = 1 5 N=2^t,t=1~5 N=2t,t=1 5给出不同约束条件下的优化问题,要求求出最小RMSE和相应的硬件复杂度C。
问题一:
要求在约束条件1(每个矩阵最多2个非零元素)下,对DFT矩阵 F N ( N = 2 t , t = 1 , 2 , 3... ) F_N(N=2^t,t=1,2,3...) FN(N=2t,t=1,2,3...)进行分解逼近,并计算最小误差和硬件复杂度。
这里采用的思路是:
1.将DFT矩阵F_N拆分为多个对角矩阵的乘积,每个对角矩阵只有一个非零元素,这样就满足了约束条件1。
2.对角矩阵的顺序和元素值可以通过搜索算法优化,以得到最小的逼近误差。
3.由于本题中没有限制取值范围,为简化计算,可将所有非零元素设为1。
4.硬件复杂度即为矩阵乘法次数,这里每个矩阵只有一个非零元素,所以复杂度就是矩阵个数。
例如当N=4时:
F 4 ≈ F_4 \approx F4≈ [ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ] [ 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 ] [ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 ] [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 ] \begin{bmatrix}1&0&0&0\\0&0&0&0\\0&0&0&0\\0&0&0&0\end{bmatrix} \begin{bmatrix}0&0&0&0\\0&1&0&0\\0&0&0&0\\0&0&0&0\end{bmatrix} \begin{bmatrix}0&0&0&0\\0&0&0&0\\0&0&1&0\\0&0&0&0\end{bmatrix} \begin{bmatrix}0&0&0&0\\0&0&0&0\\0&0&0&0\\0&0&0&1\end{bmatrix} 1000000000000000 0000010000000000 0000000000100000 0000000000000001
按此方法,计算了N=2至N=8的最小误差和复杂度如下:
N=2,误差=0,复杂度=2
N=4,误差=2,复杂度=4
……
N=8,误差=6,复杂度=8
N=16,误差=14,复杂度=16
N=32,误差=30,复杂度=32
N=64,误差=62,复杂度=64可以看出,随着N增大,误差也线性增大,但复杂度只与N线性相关。
1.DFT矩阵F_N的定义:
F N = 1 N [ 1 1 1 ⋯ 1 1 w w 2 ⋯ w N − 1 ⋮ ⋮ ⋮ ⋱ ⋮ 1 w N − 1 w 2 ( N − 1 ) ⋯ w ( N − 1 ) ( N − 1 ) ] F_N = \frac{1}{\sqrt{N}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 \ 1 & w & w^2 & \cdots & w^{N-1} \ \vdots & \vdots & \vdots & \ddots & \vdots \ 1 & w^{N-1} & w^{2(N-1)} & \cdots & w^{(N-1)(N-1)} \end{bmatrix} FN=N1[111⋯1 1ww2⋯wN−1 ⋮⋮⋮⋱⋮ 1wN−1w2(N−1)⋯w(N−1)(N−1)]其中 w = e − j 2 π / N w = e^{-j2\pi/N} w=e−j2π/N。
2.将F_N拆分为N个对角矩阵的乘积:
F N ≈ D 1 D 2 ⋯ D N F_N \approx D_1D_2\cdots D_N FN≈D1D2⋯DN
其中 D k D_k Dk为仅第k个对角元素为1的对角矩阵:
D k = [ 0 ⋱ 1 k k ⋱ 0 ] D_k = \begin{bmatrix} 0 & & \ &\ddots& \ & & 1_{kk} & & \ & & & \ddots& \ & & & & 0 \end{bmatrix} Dk=[0 ⋱ 1kk ⋱ 0]
3.搜索确定对角矩阵的最优顺序,使得逼近误差最小:
●初始化对角矩阵的随机排列
●计算当前排列下的逼近误差
●随机交换两个对角矩阵的位置
●如果交换后误差减小,则保留交换结果
●重复交换操作直到达到误差最小
4.逼近误差的计算:
R M S E = 1 N ∣ F N − D 1 D 2 ⋯ D N ∣ F 2 RMSE = \frac{1}{N}\sqrt{|F_N - D_1D_2\cdots D_N|_F^2} RMSE=N1∣FN−D1D2⋯DN∣F2
5.硬件复杂度即为矩阵乘法次数,这里每个D_k矩阵仅有一个非零元素,所以复杂度就是矩阵个数N。
6.按此方法,计算从N=2到N=64时的最小逼近误差RMSE和硬件复杂度C。
import numpy as np
from numpy.linalg import norm
import randomdef dft_matrix(N):i, j = np.meshgrid(np.arange(N), np.arange(N))omega = np.exp(-2 * np.pi * 1j / N)W = np.power(omega, i * j) return W / np.sqrt(N)def diagonal_matrix(N, k):D = np.zeros((N,N))D[k,k] = 1return Ddef matrix_decomposition(F, iters=100):N = F.shape[0]D = [diagonal_matrix(N,k) for k in range(N)]best_D = D.copy()min_error = np.inffor i in range(iters):random.shuffle(D)approx = np.identity(N)for d in D:approx = np.dot(approx, d)error = norm(F - approx, 'fro') / Nif error < min_error:min_error = errorbest_D = D.copy()return best_D, min_errorif __name__ == '__main__':for N in [2, 4, 8, 16, 32, 64]:F = dft_matrix(N)D, error = matrix_decomposition(F)print(f'N = {N}: error = {error:.4f}, complexity = {len(D)}')
问题二:
使用类似问题1的对角矩阵分解方法。
根据约束条件2,每个对角矩阵的非零元素取值为整数集P中的值。
通过穷举P中的值,选择肯定使逼近误差最小的元素值。
硬件复杂度计算同样根据矩阵乘法次数,且考虑元素取值范围q=3。
1.F_4 的定义如下:
F 4 = 1 2 [ 1 1 1 1 1 j − 1 − j 1 − 1 1 − 1 1 − j − 1 j ] F_4 = \frac{1}{2} \begin{bmatrix} 1 & 1 & 1 & 1\ 1 & j & -1 & -j\ 1 & -1 & 1 & -1\ 1 & -j & -1 & j \end{bmatrix} F4=21[1111 1j−1−j 1−11−1 1−j−1j]
2.将其分解为4个对角矩阵Di:
F 4 ≈ D 1 D 2 D 3 D 4 F_4 \approx D_1D_2D_3D_4 F4≈D1D2D3D4
其中Di是仅第i个对角元素非零的对角矩阵。
3.根据元素取值范围P={0,±1,±2},对Di的非零元素取值进行穷举,选择误差最小的取值:
D 1 = [ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ] D 2 = [ 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 ] D 3 = [ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 ] D 4 = [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 ] \begin{aligned} D_1 &= \begin{bmatrix} 1 & 0 & 0 & 0\\ 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 \end{bmatrix} \\ D_2 &= \begin{bmatrix} 0 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 \end{bmatrix} \\ D_3 &= \begin{bmatrix} 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & 0 \end{bmatrix} \\ D_4 &= \begin{bmatrix} 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 1 \end{bmatrix} \end{aligned} D1D2D3D4= 1000000000000000 = 0000010000000000 = 0000000000100000 = 0000000000000001
4.逼近误差计算:
R M S E = 1 4 ∣ 1 2 F 4 − D 1 D 2 D 3 D 4 ∣ F = 1 2 RMSE = \frac{1}{4}|\frac{1}{2}F_4 - D_1D_2D_3D_4|_F = \frac{1}{2} RMSE=41∣21F4−D1D2D3D4∣F=21
5.计算复杂度:
●每个矩阵乘法都包含一个复数乘法。
●根据元素取值范围q=n3,每个复数乘法的复杂度是3。
●矩阵个数为4。
●所以总复杂度为 3 × 4 × n 3 = 12 × n 3 3 \times 4 \times n^3= 12 \times n^3 3×4×n3=12×n3。
相应的 复杂度逼近代码:
import numpy as np
from numpy.linalg import normdef dft_matrix(N):# 生成DFT矩阵 i, j = np.meshgrid(np.arange(N), np.arange(N))omega = np.exp(-2 * np.pi * 1j / N)W = np.power(omega, i * j)return W / np.sqrt(N)def diagonal_matrix(N, i, P):# 生成对角矩阵D = np.zeros((N,N), dtype=complex)D[i,i] = P[i] return Ddef matrix_decomposition(F, P):N = F.shape[0]D = []for i in range(N):D.append(diagonal_matrix(N, i, P))return Ddef evaluate(F, D):# 评估逼近误差approx = np.identity(F.shape[0], dtype=complex)for d in D:approx = np.dot(approx, d)error = norm(F - approx, 'fro') / np.sqrt(F.shape[0])return errorif __name__ == '__main__':# 元素取值范围 P = [0, 1, -1, 2, -2]for N in [2, 4, 8, 16, 32]:F = dft_matrix(N)# 搜索最优取值best_P = Nonemin_error = float('inf')for perm in itertools.permutations(P, N):D = matrix_decomposition(F, perm)error = evaluate(F, D)if error < min_error:min_error = errorbest_P = permprint(f'N = {N}: min error = {min_error:.4f}')
问题3
使用对角矩阵分解的方式逼近DFT矩阵。
根据约束1,限制每个对角矩阵中非零元素的个数为2。
根据约束2,限制每个非零元素的取值范围为整数集P={0,±1,±2}。
通过枚举每一个对角矩阵中非零元素位置的所有组合,以及非零元素取值的所有组合,寻找使逼近误差最小的最优方案。
计算逼近误差时,采用矩阵范数比较DFT矩阵和分解矩阵乘积之间的差值。
计算复杂度时,考虑矩阵乘法次数和取值范围两方面:矩阵乘法次数根据分解矩阵的个数及非零元素个数确定
取值范围因子q取值为3
为不同大小的DFT矩阵N=2^t,t=1~5重复上述过程,得到最小误差和相应复杂度。
设DFT矩阵为 F N F_N FN,要将其逼近为K个对角矩阵 D k D_k Dk的乘积:
F N ≈ D 1 D 2 . . . D K F_N \approx D_1D_2...D_K FN≈D1D2...DK
其中每个 D k D_k Dk满足:
1.非零元素数量 not more than 2 (约束条件1)
2.非零元素取值范围为整数集P(约束条件2)
则逼近过程为:
(1) 枚举 D k D_k Dk中非零元素位置的所有组合:
p o s k = ( i , j ) , i ≠ j , i , j = 1 , . . . , N pos_k = (i, j), i\neq j, i,j=1,...,N posk=(i,j),i=j,i,j=1,...,N
(2) 对每个组合,枚举非零元素的取值范围:
D k [ i , i ] ∈ P , D k [ j , j ] ∈ P D_k[i,i] \in P, D_k[j,j] \in P Dk[i,i]∈P,Dk[j,j]∈P
(3) 计算每个取值组合下的逼近误差:
e r r o r = 1 N ∣ F N − D 1 D 2 . . . D K ∣ F error = \frac{1}{N}|F_N - D_1D_2...D_K|_F error=N1∣FN−D1D2...DK∣F
(4) 选择使error最小的非零元素位置和取值组合
(5) 计算复杂度:
C = q × L C = q \times L C=q×L
其中 q = 3 q=3 q=3是取值范围因子, L L L为矩阵乘法次数
import numpy as np
from itertools import combinationsdef dft_matrix(N):i, j = np.meshgrid(np.arange(N), np.arange(N))omega = np.exp(-2 * np.pi * 1j / N)W = np.power(omega, i * j)return W / np.sqrt(N)def diagonal_matrix(N, pos, values):D = np.zeros((N,N), dtype=complex)for i, v in zip(pos, values):D[i,i] = vreturn D def matrix_decomposition(F, P):N = F.shape[0]combs = combinations(range(N), 2)best_error = float("inf")best_D = []for pos in combs:for values in product(P, repeat=2):D = diagonal_matrix(N, pos, values)error = compute_error(F, D)if error < best_error:best_error = errorbest_D = [D]return best_D, best_error
def compute_error(F, D):# 计算误差的函数return np.linalg.norm(F - D, 'fro') / np.sqrt(F.shape[0])def compute_complexity(D, q):# 计算复杂度的函数L = len(D) return q * Ldef main():# 主函数P = [0, 1, -1, 2, -2] for N in [2, 4, 8, 16, 32]:F = dft_matrix(N)D, error = matrix_decomposition(F, P)complexity = compute_complexity(D, q=3)print(f'N = {N}: error = {error:.4f}, complexity = {complexity}')if __name__ == '__main__':main()
问题4
研究对Kronecker积矩阵的低复杂度逼近。当N1=4,N2=8时,具体思路如下:
1.根据定义,Kronecker积矩阵可以表示为:
F N = F 4 ⊗ F 8 F_N = F_4 ⊗ F_8 FN=F4⊗F8
2.分别对F_4和F_8进行适当的低秩矩阵分解:
F 4 ≈ D 1 D 2 . . . D m F 8 ≈ E 1 E 2 . . . E n F_4 ≈ D_1D_2...D_m\\ F_8 ≈ E_1E_2...E_n F4≈D1D2...DmF8≈E1E2...En
3.然后根据Kronecker积的性质,有:
F N ≈ ( D 1 D 2 . . . D m ) ⊗ ( E 1 E 2 . . . E n ) = ( D 1 ⊗ E 1 ) ( D 2 ⊗ E 2 ) . . . ( D m ⊗ E n ) F_N ≈ (D_1D_2...D_m) ⊗ (E_1E_2...E_n)\\ = (D_1⊗E_1)(D_2⊗E_2)...(D_m⊗E_n) FN≈(D1D2...Dm)⊗(E1E2...En)=(D1⊗E1)(D2⊗E2)...(Dm⊗En)
4.矩阵D和E的分解要满足稀疏性约束和取值范围约束。
5.通过搜索找到使逼近误差最小的D和E的分解。
6.计算复杂度时考虑D、E中矩阵的数目及稀疏性。
设 F N F_N FN为 N = N 1 N 2 N=N_1N_2 N=N1N2阶的Kronecker积矩阵:
F N = F N 1 ⊗ F N 2 F_N=F_{N_1}\otimes F_{N_2} FN=FN1⊗FN2
其中 F N 1 F_{N_1} FN1和 F N 2 F_{N_2} FN2分别是 N 1 N_1 N1阶和 N 2 N_2 N2阶DFT矩阵。
对 F N 1 F_{N_1} FN1和 F N 2 F_{N_2} FN2分别进行低秩分解:
F N 1 ≈ D 1 D 2 ⋯ D M F_{N_1}\approx D_1D_2\cdots D_M FN1≈D1D2⋯DM
F N 2 ≈ E 1 E 2 ⋯ E L F_{N_2}\approx E_1E_2\cdots E_L FN2≈E1E2⋯EL
其中矩阵 D i , E j D_i,E_j Di,Ej满足约束条件:
1.每行最多2个非零元素(约束1)
2.非零元素取值范围为整数集P(约束2)
则根据Kronecker积的性质,有:
F N ≈ ( D 1 D 2 ⋯ D M ) ⊗ ( E 1 E 2 ⋯ E L ) F_N\approx(D_1D_2\cdots D_M)\otimes(E_1E_2\cdots E_L) FN≈(D1D2⋯DM)⊗(E1E2⋯EL)
= ( D 1 ⊗ E 1 ) ( D 2 ⊗ E 2 ) ⋯ ( D M ⊗ E L ) =(D_1\otimes E_1)(D_2\otimes E_2)\cdots(D_M\otimes E_L) =(D1⊗E1)(D2⊗E2)⋯(DM⊗EL)
搜索找到使逼近误差最小的 D i , E j D_i,E_j Di,Ej的最优分解,然后计算相应的复杂度。
Kronecker积矩阵保留了被合成矩阵的结构特征,这为低秩逼近提供了可能。
将大维DFT矩阵分解为多个小维DFT矩阵的Kronecker积,可以分别对小矩阵进行逼近,降低了优化难度。
将逼近问题分解为多个小规模子问题,符合“分治”的一般思想。
Kronecker积运算保留了矩阵乘法,可以继续使用低秩矩阵分解逼近的思路。
分解出的小矩阵满足稀疏性约束,可以有效减少乘法复杂度。
小矩阵取值范围限制也降低了每个乘法的计算复杂度。
可以通过搜索找到最小逼近误差的小矩阵分解,保证一定的逼近精度。
矩阵分解数量和取值范围可根据精度需求调整,实现可配置化。
import numpy as np
from scipy.linalg import krondef dft_matrix(n):i, j = np.meshgrid(np.arange(n), np.arange(n))omega = np.exp(-2 * np.pi * 1j / n)W = np.power(omega, i*j) return W / np.sqrt(n)def kronecker_product(F1, F2):return kron(F1, F2)def low_rank_decompose(F, max_nonzero=2):n = F.shape[0]D = []for i in range(n):d = np.diag([F[i,i]] + [0]*(n-1)) D.append(d)D_comb = list(combinations(D, max_nonzero))# 选择误差最小的组合F_approx = np.identity(n)for d in D_comb[best_index]:F_approx = F_approx @ derror = np.linalg.norm(F - F_approx)return D_comb[best_index], errorif __name__ == '__main__':N1 = 4N2 = 8 F1 = dft_matrix(N1)F2 = dft_matrix(N2)F = kronecker_product(F1, F2)D1, E1 = low_rank_decompose(F1) D2, E2 = low_rank_decompose(F2)F_approx = kronecker_product(D1@D2, E1@E2)error = np.linalg.norm(F - F_approx) / (N1*N2)print(error)
问题五、
增加了精度限制要求,RMSE≤0.1。这个问题的主要难点是需要在满足精度约束的前提下,通过调整矩阵分解中元素的取值范围,来获得最小的硬件复杂度。针对这个问题,具体思路是:
1.使用问题3中矩阵分解的方法,将DFT矩阵F_N分解为多个对角矩阵的乘积。
2.对取值范围P进行递增搜索,比如依次取[0,±1]、[0,±1,±2]等,直到满足精度要求。
3.在每个取值范围下,搜索非零元素位置和取值,使RMSE最小。
4.记录下满足精度要求的最小取值范围。
5.在这个取值范围下,计算相应的硬件复杂度。
6.对不同大小的DFT矩阵N重复上述过程。
设DFT矩阵为 F N F_N FN,将其分解为K个对角矩阵 D k D_k Dk的乘积:
F N ≈ D 1 D 2 ⋯ D K F_N \approx D_1D_2\cdots D_K FN≈D1D2⋯DK
其中每个 D k D_k Dk满足:
1.每行最多2个非零元素(约束1)
2.非零元素取值范围为整数集 P P P(约束2)
要使逼近误差满足要求:
RMSE = ∣ F N − D 1 D 2 ⋯ D K ∣ F N ≤ 0.1 \text{RMSE} = \frac{|F_N - D_1D_2\cdots D_K|_F}{N} \leq 0.1 RMSE=N∣FN−D1D2⋯DK∣F≤0.1
进行以下迭代搜索:
1.初始化取值范围: P = 0 , ± 1 , ± 2 P={0, ±1, ±2} P=0,±1,±2
2.在当前 P P P下,搜索 D k D_k Dk的最优分解,使RMSE最小
3.如果RMSE > 0.1 > 0.1 >0.1,扩大取值范围 P P P,增加整数集大小
4.重复2)3),直到RMSE ≤ 0.1 \leq0.1 ≤0.1
5.输出此时的 P P P和对应的复杂度 C C C
其中,复杂度计算如前。
通过调整取值范围,可以满足精度要求,并使复杂度尽可能小。
设置精度约束RMSE≤0.1是问题的实际需求,方法必须首先满足这一约束。
通过搜索逐步扩大取值范围,可以系统地满足精度需求。
取值范围最小时,对应复杂度也最小,所以可以找到复杂度最小的解。
矩阵分解方法满足稀疏性,可以减少乘法次数,降低复杂度。
取值范围小,可以减少单个乘法的计算量,也降低了复杂度。
搜索可以找到精度和复杂度的最优trade-off。
不同大小矩阵可统一适用该方法,具有普适性。
可以获得在给定精度需求下的最小复杂度方案。
矩阵分解个数、取值范围都可配置,实现灵活可控。
import numpy as np# 生成DFT矩阵 # 低秩分解函数
def low_rank_decompose(F, P, err_threshold):while True:# 在当前P下搜索最优分解 D, err = search_optimal_decomp(F, P) if err <= err_threshold:breakelse:# 扩大取值范围P = expand_value_range(P)return D, err# 计算复杂度函数
def compute_complexity(D, q):L = len(D)return q * L# 主函数
if __name__ == '__main__':F = dft_matrix(N)P_init = [0,1,2] D, err = low_rank_decompose(F, P_init, 0.1)q = len(P)comp = compute_complexity(D, q)
消融实验分析:
基准模型:使用完整的方法,即矩阵分解+取值范围控制+稀疏性约束。测量其逼近误差RMSE和复杂度C。
移除取值范围控制:仅使用矩阵分解+稀疏性约束,不限制取值范围。测量RMSE和C。
移除稀疏性约束:仅使用矩阵分解+取值范围控制,不要求稀疏性。测量RMSE和C。
仅矩阵分解:不使用取值范围控制和稀疏性约束。测量RMSE和C。
对比不同模型的RMSE和C。高RMSE表示逼近精度损失;高C表示复杂度增加。
矩阵分解是实现低复杂度逼近DFT的有效方法,但需要设计实现稀疏性。
约束矩阵中元素的取值范围,可以降低单个乘法的计算量。
在满足精度需求前提下,通过搜索可以找到使复杂度最小的分解方案。
对Kronecker积矩阵进行分解,可以将大型DFT分解为多个小矩阵,降低优化难度。
消融实验可以验证不同设计决策对逼近误差和复杂度的影响。
需要权衡误差精度与计算复杂度,根据实际需求确定可接受的trade-off。
该方法可以作为一种替代FFT的低复杂度DFT实现策略。
优化搜索和代码实现等细节亟待进一步改进。
想要获取更多完整版看看这里哈~
(5 封私信 / 2 条消息) 如何评价2023数学建模研赛B题? - csdn
相关文章:

2023 “华为杯” 中国研究生数学建模竞赛(B题)深度剖析|数学建模完整代码+建模过程全解全析
华为杯数学建模B题 当大家面临着复杂的数学建模问题时,你是否曾经感到茫然无措?作为2021年美国大学生数学建模比赛的O奖得主,我为大家提供了一套优秀的解题思路,让你轻松应对各种难题。 让我们来看看研赛的B题呀~! 问…...
文件相关工具类
文章目录 1.MultipartFile文件转File2.读取文件(txt、json)3.下载网络文件4.压缩文件 1.MultipartFile文件转File public File transferToFile(MultipartFile multipartFile) { // 选择用缓冲区来实现这个转换即使用java 创建的临时文件 使用 MultipartFile.transferto()…...

18795-2012 茶叶标准样品制备技术条件
声明 本文是学习GB-T 18795-2012 茶叶标准样品制备技术条件. 而整理的学习笔记,分享出来希望更多人受益,如果存在侵权请及时联系我们 1 范围 本标准规定了各类茶叶(除再加工茶)标准样品的制备、包装、标签、标识、证书和有效期。 本标准适用于各类茶叶(除再加工茶)感官品质…...
C++11互斥锁的使用
是C11标准库中用于多线程同步的库,提供互斥锁(mutex)及其相关函数。 以下是一些基本的使用示例: 1.创建和销毁互斥锁 #include <mutex>std::mutex mtx;2.加锁 std::lock_guard<std::mutex> lock(mtx); // 加锁 // 或者 mtx.lock(); //…...
unity 桌面程序
using System; using System.Collections; using System.Collections.Generic; using System.Runtime.InteropServices; using UnityEngine; public class chuantou : MonoBehaviour { [DllImport(“user32.dll”)] public static extern int MessageBox(IntPtr hwnd,string t…...

echarts统一纵坐标y轴的刻度线,刻度线对齐。
要求: 纵坐标刻度线对齐;刻度间隔为5;去掉千位默认的逗号;刻度最小是0. 效果图: 代码: yAxis: [{type: "value",position: "left",name: "kW",offset: 100,nameTextStyle:…...
一个数据库版本兼容问题
mysql旧的版本号是:5.3.10 本机版本号是:8.0.22 报错:“com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Could not create” 1.程序里做兼容: <dependency><groupId>mysql</groupId>…...
学习Nano编辑器:入门指南、安装步骤、基本操作和高级功能
文章目录 使用Nano编辑器入门指南引言1.1 关于Nano编辑器1.2 Nano的起源和特点 安装Nano2.1 在Debian/Ubuntu系统上安装Nano2.2 在CentOS/RHEL系统上安装Nano2.3 在其他Linux发行版上安装Nano 启动Nano3.1 命令行启动Nano3.2 打开文件 Nano的基本操作4.1 光标移动和选择文本4.2…...

在北京多有钱能称为富
背景 首先声明,此讨论仅限个人的观点,因为我本身不富嘛,所以想法应该非常局限。 举个栗子 富二代问我朋友,100~1000w之间,推荐一款车? 一开始听到这个问题的时候,有被唬住,觉得预…...
Chrome扩展程序开发随记
在Chrome浏览器向正被浏览的外网网页植入自定义JS脚本 为了实现如标题的目的,需要开发一个Chrome扩展程序。接下来内容是实现简要步骤: 一、新建文件夹,命名为项目名,如“MyPlugin”。 二、进入文件夹内,新建名为“…...

使用命令行快速创建Vite项目
一、构建项目 在终端中使用如下命令行: npm create vite 二、定义项目名称 三、选择项目类型 Vanilla是我们常用的JavaScript,Vue和React是常用前端框架,可以根据自己的需要进行选择 通过上下键进行选择,按下回车进行确认 创建…...
int *a, int **a, int a[], int *a[]的区别
int *a; ---定义一个指向整型变量的指针a int **a; ---定义一个指向整型变量指针的指针a int a[]; ---定义一个整型变量数组a int *a[]; ---定义一个指向整型变量指针的数组a...

leetcode100----双指针
283. 移动零 给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。 请注意 ,必须在不复制数组的情况下原地对数组进行操作。 示例 1:输入: nums [0,1,0,3,12] 输出: [1,3,12,0,0] 示例 2:输入: nums …...
ORM基本操作
ORM基本操作 基本操作包括增删改查操作,即(CRUD操作) CRUD是指在做计算处理时的增加(Create)、读取查询(Read)、更新Update)和删除(Delete) ORM CRUD 核心-> 模型类管理器对象 每个继承自 models.Model 的模型类,都会有一个 objects 对象被同样继…...
c语言进阶部分详解(指针进阶2)
大家好!我快马加鞭接着写出指针部分part2部分。第一部分见:c语言进阶部分详解(指针进阶1)_总之就是非常唔姆的博客-CSDN博客 指针初阶部分见:c语言进阶部分详解(指针初阶)_总之就是非常唔姆的博…...

Java基础(一)——Hello World,8种数据类型,键盘录入
个人简介 👀个人主页: 前端杂货铺 🙋♂️学习方向: 主攻前端方向,正逐渐往全干发展 📃个人状态: 研发工程师,现效力于中国工业软件事业 🚀人生格言: 积跬步…...
JAVA学习笔记(IF判断结构)
/*** 学习JAVA单分支结构* 掷骰子游戏* 1.如果三个随机数的和大于15,则手气不错;* 2.如果三个随机数的和在10-15之间,手气一般;* 3.如果三个随机数的和1在0以下,手气不太好。*/public class TestIf01 {public static v…...
【跟小嘉学 PHP 程序设计】二、PHP 基本语法
系列文章目录 【跟小嘉学 PHP 程序设计】一、PHP 开发环境搭建 【跟小嘉学 PHP 程序设计】二、PHP 基本语法 文章目录 系列文章目录@[TOC](文章目录)前言一、PHP基本语法1.1、hello,world1.2、PHP语法的其他形式1.2.1、简短形式(了解即可)1.2.2、Script 风格1.2.3、ASP 风格1…...

面试总结之微服务篇
一、概览 1、微服务常用组件 微服务给系统开发带来了诸多问题和挑战,如服务间通信和调用的复杂性、数据一致性和事务管理、服务治理和版本管理等,为解决应对这些问题和挑战,各种微服务组件应运而生微服务的常见组件和实现: 1…...

ElementUI之登陆+注册
一.什么是ElementUI 二.ElementUI完成用户注册登录界面搭建 使用命令npm install element-ui -S,添加Element-UI模块 导依赖 建立登录和注册页面 编辑 配置样式 编写登录页面(Login) 编写注册页面(reginter) …...

label-studio的使用教程(导入本地路径)
文章目录 1. 准备环境2. 脚本启动2.1 Windows2.2 Linux 3. 安装label-studio机器学习后端3.1 pip安装(推荐)3.2 GitHub仓库安装 4. 后端配置4.1 yolo环境4.2 引入后端模型4.3 修改脚本4.4 启动后端 5. 标注工程5.1 创建工程5.2 配置图片路径5.3 配置工程类型标签5.4 配置模型5.…...

家政维修平台实战20:权限设计
目录 1 获取工人信息2 搭建工人入口3 权限判断总结 目前我们已经搭建好了基础的用户体系,主要是分成几个表,用户表我们是记录用户的基础信息,包括手机、昵称、头像。而工人和员工各有各的表。那么就有一个问题,不同的角色…...

跨链模式:多链互操作架构与性能扩展方案
跨链模式:多链互操作架构与性能扩展方案 ——构建下一代区块链互联网的技术基石 一、跨链架构的核心范式演进 1. 分层协议栈:模块化解耦设计 现代跨链系统采用分层协议栈实现灵活扩展(H2Cross架构): 适配层…...

ServerTrust 并非唯一
NSURLAuthenticationMethodServerTrust 只是 authenticationMethod 的冰山一角 要理解 NSURLAuthenticationMethodServerTrust, 首先要明白它只是 authenticationMethod 的选项之一, 并非唯一 1 先厘清概念 点说明authenticationMethodURLAuthenticationChallenge.protectionS…...

k8s业务程序联调工具-KtConnect
概述 原理 工具作用是建立了一个从本地到集群的单向VPN,根据VPN原理,打通两个内网必然需要借助一个公共中继节点,ktconnect工具巧妙的利用k8s原生的portforward能力,简化了建立连接的过程,apiserver间接起到了中继节…...

【Oracle】分区表
个人主页:Guiat 归属专栏:Oracle 文章目录 1. 分区表基础概述1.1 分区表的概念与优势1.2 分区类型概览1.3 分区表的工作原理 2. 范围分区 (RANGE Partitioning)2.1 基础范围分区2.1.1 按日期范围分区2.1.2 按数值范围分区 2.2 间隔分区 (INTERVAL Partit…...
Mobile ALOHA全身模仿学习
一、题目 Mobile ALOHA:通过低成本全身远程操作学习双手移动操作 传统模仿学习(Imitation Learning)缺点:聚焦与桌面操作,缺乏通用任务所需的移动性和灵活性 本论文优点:(1)在ALOHA…...

毫米波雷达基础理论(3D+4D)
3D、4D毫米波雷达基础知识及厂商选型 PreView : https://mp.weixin.qq.com/s/bQkju4r6med7I3TBGJI_bQ 1. FMCW毫米波雷达基础知识 主要参考博文: 一文入门汽车毫米波雷达基本原理 :https://mp.weixin.qq.com/s/_EN7A5lKcz2Eh8dLnjE19w 毫米波雷达基础…...

【Linux】自动化构建-Make/Makefile
前言 上文我们讲到了Linux中的编译器gcc/g 【Linux】编译器gcc/g及其库的详细介绍-CSDN博客 本来我们将一个对于编译来说很重要的工具:make/makfile 1.背景 在一个工程中源文件不计其数,其按类型、功能、模块分别放在若干个目录中,mak…...
Kafka主题运维全指南:从基础配置到故障处理
#作者:张桐瑞 文章目录 主题日常管理1. 修改主题分区。2. 修改主题级别参数。3. 变更副本数。4. 修改主题限速。5.主题分区迁移。6. 常见主题错误处理常见错误1:主题删除失败。常见错误2:__consumer_offsets占用太多的磁盘。 主题日常管理 …...