【模式识别】计算机科学博士课程作业解析

作业二

2.1 最小风险贝叶斯决策分类计算

1、请给出以下问题的求解步骤，逐步给出计算过程：

已知条件为

P(w_1) = 0.9

P(w_2)=0.1

p(x|w_1)=0.2

p(x|w_w)=0.4

λ 11 = 0 \lambda_{11}=0 λ11​=0, λ 12 = 6 \lambda_{12}=6 λ12​=6

λ 21 = 1 \lambda_{21}=1 λ21​=1, λ 22 = 0 \lambda_{22}=0 λ22​=0

根据以下决策表，按最小风险贝叶斯决策进行分类

w_1w_2
a_106
a_210

解：

根据最小风险贝叶斯决策，当后验概率乘以代价最小时，我们才能选择正确的分类。所以首先需要求出后验概率和总代价。

根据贝叶斯公式，对于给定的观测值 x x x，我们可以得到后验概率为：

P ( w 1 ∣ x ) = P ( x ∣ w 1 ) P ( w 1 ) P ( x ) P(w_1|x) = \frac{P(x|w_1)P(w_1)}{P(x)} P(w1​∣x)=P(x)P(x∣w1​)P(w1​)​

P ( w 2 ∣ x ) = P ( x ∣ w 2 ) P ( w 2 ) P ( x ) P(w_2|x) = \frac{P(x|w_2)P(w_2)}{P(x)} P(w2​∣x)=P(x)P(x∣w2​)P(w2​)​

其中分母为归一化常数：

P ( x ) = P ( x ∣ w 1 ) P ( w 1 ) + P ( x ∣ w 2 ) P ( w 2 ) P(x)=P(x|w_1)P(w_1)+P(x|w_2)P(w_2) P(x)=P(x∣w1​)P(w1​)+P(x∣w2​)P(w2​)

代入题目中给出的条件：

P ( w 1 ) = 0.9 P ( w 2 ) = 0.1 p ( x ∣ w 1 ) = 0.2 p ( x ∣ w w ) = 0.4 P(w_1)=0.9\\P(w_2)=0.1\\p(x|w_1)=0.2\\p(x|w_w)=0.4 P(w1​)=0.9P(w2​)=0.1p(x∣w1​)=0.2p(x∣ww​)=0.4

则对于任意的 x x x，

P ( x ) = 0.9 × 0.2 + 0.1 × 0.4 = 0.22 P ( w 1 ∣ x ) = 0.2 × 0.9 0.22 ≈ 0.818 P ( w 2 ∣ x ) = 0.4 × 0.1 0.22 ≈ 0.182 \begin{aligned} &P(x) = 0.9\times 0.2 + 0.1 \times 0.4 = 0.22\\ &P(w_1|x) = \frac{0.2\times 0.9}{0.22} \approx 0.818\\ &P(w_2|x) = \frac{0.4\times 0.1}{0.22} \approx 0.182\\ \end{aligned} ​P(x)=0.9×0.2+0.1×0.4=0.22P(w1​∣x)=0.220.2×0.9​≈0.818P(w2​∣x)=0.220.4×0.1​≈0.182​

接下来计算总代价。函数表格中已经给出了各种决策取值下的代价。因此只需将每个决策取值下的代价与相应的后验概率相乘，并将两者相加即可得到总代价：

R ( a 1 ∣ x ) = λ 11 P ( w 1 , a 1 ) + λ 12 P ( w 2 , a 1 ) = 0 + 6 × 0.182 = 1.092 R(a_1|x) =\lambda_{11} P(w_1, a_1)+\lambda_{12} P(w _2,a _1 ) \\ =0+ 6\times 0.182 \\ =1.092 R(a1​∣x)=λ11​P(w1​,a1​)+λ12​P(w2​,a1​)=0+6×0.182=1.092
R ( a 2 ∣ x ) = λ 21 P ( w l , a 2 ) + λ 22 P ( w 2 , a 2 ) = 1 × 0.818 = 0.818 R(a _2 | x)=\lambda_{21} P(w _l,a _2)+\lambda_{22} P(w _2,a _2 ) \\ =1\times 0.818\\ =0.818 \\ R(a2​∣x)=λ21​P(wl​,a2​)+λ22​P(w2​,a2​)=1×0.818=0.818

根据最小风险贝叶斯决策，则选择R最小化的决策。最终选择 a 2 a_2 a2​作为分类结果。

2.2 最小风险贝叶斯决策和最小错误率贝叶斯决策的区别

最小风险贝叶斯决策和最小错误率贝叶斯决策都是常用的贝叶斯决策方法，区别如下：

（1）决策目标不同：最小风险贝叶斯决策旨在使总体风险最小化，即将各种可能出现的损失考虑进来，以最小化总损失；而最小错误率贝叶斯决策则旨在使分类错误率最小化。

（2）决策规则不同：最小风险贝叶斯决策采用期望损失作为决策依据，通过比较各个类别的期望损失大小来选择具有最小期望损失的类别作为分类结果；而最小错误率贝叶斯决策则采用后验概率作为分类依据，选择后验概率值最大的类别作为分类结果。

（3）假设条件不同：最小风险贝叶斯决策需要知道各种情形下的损失函数和先验概率分布；而最小错误率贝叶斯决策只需要知道各类别条件概率分布和先验概率分布即可。

（4） 应用场景不同：由于两种方法所需信息不同，因此应用场景也有所差异。如果已知各类别之间的代价或收益关系，并且可以明确量化，则适合采用最小风险贝叶斯决策；而如果只关注分类准确性，并且无法精确量化代价或收益，则适合采用最小错误率贝叶斯决策。

作业三

3.1 最小风险贝叶斯决策实现

请用python编写程序实现：

设正态分布的均值分别为 μ 1 = [ 1 , 1 ] T \mu_1=[1 ,1]^T μ1​=[1,1]T, μ 2 = [ 1.51.5 ] T \mu_2 =[1.5 1.5]^T μ2​=[1.51.5]T协方差矩阵均为0.2I，先验概率相等，决策表为下公式。由正态分布生成各1000个二维向量的数据集，利用其中的800个样本，采用最大似然估计方法估计样本分布的参数，利用最小风险贝叶斯决策方法对其余200个样本进行决策，并计算识别率。
[ 0 1 0.5 0 ] \begin{bmatrix} 0 & 1 \\ 0.5 & 0 \end{bmatrix} [00.5​10​]

import numpy as np
from scipy.stats import multivariate_normal

# 生成数据集
def generate_data(mu1, mu2, cov, num_samples):
    # 生成服从正态分布的数据
    data1 = np.random.multivariate_normal(mu1, cov, num_samples)
    data2 = np.random.multivariate_normal(mu2, cov, num_samples)
    return data1, data2

# 估计样本分布的参数
def estimate_parameters(data):
    # 计算均值
    mean = np.mean(data, axis=0)
    # 计算协方差矩阵
    cov = np.cov(data.T)
    return mean, cov

# 最小风险贝叶斯决策
def minimum_risk_bayesian_decision(data, means, covs, prior_probs):
    num_samples = data.shape[0]
    num_classes = len(means)
    decisions = np.zeros(num_samples)

    for i in range(num_samples):
        # 计算样本在每个类别下的后验概率
        posterior_probs = np.zeros(num_classes)
        for j in range(num_classes):
            posterior_probs[j] = multivariate_normal.pdf(data[i], means[j], covs[j]) * prior_probs[j]

        # 进行决策
        decisions[i] = np.argmax(posterior_probs)

    return decisions

# 计算识别率
def compute_accuracy(true_labels, predicted_labels):
    num_samples = true_labels.shape[0]
    num_correct = np.sum(true_labels == predicted_labels)
    accuracy = num_correct / num_samples
    return accuracy

# 定义参数
mu1 = np.array([1, 1])
mu2 = np.array([1.5, 1.5])
cov = np.array([[0, 1], [0.5, 0]])
prior_probs = np.array([0.5, 0.5])

# 生成数据集
num_samples = 1000
data1, data2 = generate_data(mu1, mu2, cov, num_samples)

# 估计样本分布的参数
train_data = np.concatenate((data1[:800], data2[:800]), axis=0)
train_labels = np.concatenate((np.zeros(800), np.ones(800)))
mean1, cov1 = estimate_parameters(data1[:800])
mean2, cov2 = estimate_parameters(data2[:800])
means = [mean1, mean2]
covs = [cov1, cov2]

# 最小风险贝叶斯决策
test_data = np.concatenate((data1[800:], data2[800:]), axis=0)
test_labels = np.concatenate((np.zeros(200), np.ones(200)))
decisions = minimum_risk_bayesian_decision(test_data, means, covs, prior_probs)

# 计算识别率
accuracy = compute_accuracy(test_labels, decisions)
print("识别率：", accuracy)

识别率： 0.695

3.2 手写数字识别实现

使用python实现基于朴素贝叶斯分类器实现手写数字识别。训练图像和测试图像在文件夹Handwriting下的train和test文件夹。并测试准确率。每张图片的名称规则如“1_2.png”，则表示数字1的第2张图片。

数据集下载：Handwriting.rar

import os
import numpy as np
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score
from skimage.io import imread

# 加载训练数据
def load_data(data_folder):
    X = []
    y = []
    for label in os.listdir(data_folder):
        if label.startswith('.'):
            continue
        image_path = os.path.join(data_folder, label)
        image = imread(image_path, as_gray=True)
        X.append(image.flatten())
        y.append(int(label[0]))
    return np.array(X), np.array(y)

# 加载训练数据和测试数据
train_folder = "Handwriting/train"
test_folder = "Handwriting/test"
X_train, y_train = load_data(train_folder)
X_test, y_test = load_data(test_folder)


# 训练模型
clf = MultinomialNB()
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print("准确率: {:.2%}".format(accuracy))

准确率: 53.33%

作业四

python实现最近邻算法的实现与算法评估

数据集下载：svmguide1.rar

import numpy as np
import random
from collections import Counter

########读取机器学习数据集的示例代码 (LIBSVM格式)
def load_svmfile(filename):
    X = []
    Y = []
    with open(filename, 'r') as f:
        filelines = f.readlines()
        for fileline in filelines:
            fileline = fileline.strip().split(' ')
            #print(fileline)
            Y.append(int(fileline[0]))
            tmp = []
            for t in fileline[1:]:
                if len(t)==0:
                    continue
                tmp.append(float(t.split(':')[1]))
            X.append(tmp)
    
    return np.array(X), np.array(Y)

########从这个网址下载数据集：https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/binary.html#svmguide1
########将数据集保存在当前目录下
########读取数据集
dataset = 'svmguide1'
print('Start loading dataset {}'.format(dataset))

X, Y = load_svmfile('{}.t'.format(dataset)) # test set
X_test, Y_test  = load_svmfile('{}.t'.format(dataset)) # test set
print('trainset X shape {}, train label Y shape {}'.format(X.shape, Y.shape))

Start loading dataset svmguide1
trainset X shape (4000, 4), train label Y shape (4000,)

########实现一个KNN分类器的模型，需要完成的功能包括train, test和_calculate_distances三部分
class KNN_model():
    def __init__(self, k=1):
        self.k = k
    
    def train(self, x_train, y_train):
        """Implement the training code for KNN
        Input: 
            x_train: Training instances of size (N, D), where N denotes the number of instances and D denotes the feature dimension
            y_train: Training labels of size (N, )
        """
        self.x_train = x_train
        self.y_train = y_train
    
    def test(self, x_test):
        """
        Input: Test instances of size (N, D), where N denotes the number of instances and D denotes the feature dimension
        Return: Predicted labels of size (N, )
        """
        N = x_test.shape[0]  # 测试数据数量
        y_pred = []  # 预测标签列表
        for i in range(N):  # 遍历每一组测试数据
            distances = self._calculate_distances(x_test[i])  # 计算测试数据和训练数据的距离
            nn_indices = np.argsort(distances)[:self.k]  # 距离最近的k个点的下标，从小到大排序
            nn_labels = self.y_train[nn_indices]  # 距离最近的k个点的标签
            counts = np.bincount(nn_labels)  # 统计最近的k个点中各类别的数量
            y_pred.append(np.argmax(counts))  # 最多的那一类作为预测标签
        return np.array(y_pred)

    def _calculate_distances(self, point):
        """Calculate the euclidean distance between a test instance and all points in the training set x_train
        Input: a single point of size (D, )
        Return: distance matrix of size (N, )
        """
        return np.sqrt(np.sum((self.x_train - point) ** 2, axis=1))
    
######### 将原来的训练集划分成两部分：训练和验证
random.seed(777777) #定下随机种子
N = X.shape[0] 
valid_frac = 0.2 # 设置验证集的比例为20%
valid_size = int(N*valid_frac)

# 出于简单起见，这里直接使用random shuffle来划分
shuffle_index = [i for i in range(N)]
random.shuffle(shuffle_index)
valid_index, train_index = shuffle_index[:valid_size], shuffle_index[valid_size:]
X_valid, Y_valid = X[valid_index], Y[valid_index]
X_train, Y_train = X[train_index], Y[train_index]
print('trainset X_train shape {}, validset X_valid shape {}'.format(X_train.shape, X_valid.shape))

trainset X_train shape (3200, 4), validset X_valid shape (800, 4)

######### 这里需要实现计算准确率的函数，注意我们期望的输出是百分制，如准确率是0.95，我们期望的输出是95

def cal_accuracy(y_pred, y_gt):
    '''
    y_pred: predicted labels (N,)
    y_gt: ground truth labels (N,)
    Return: Accuracy (%)
    '''
    accuracy = (y_pred == y_gt).mean()
    return accuracy * 100
# assert abs(cal_accuracy(np.zeros(Y.shape[0]), Y)-100*1089.0/3089.0)<1e-3

#####使用验证集来选择超参数
possible_k_list = [1,3,5,7,9,11] # 在本次实验中候选的超参数取值
accs = [] # 将每个取值k对应的验证集准确率加入列表
for k in possible_k_list:
    #####模型的超参数设置为k
    model = KNN_model(k=k)
    #####在训练集上训练, 提示: model.train()
    model.train(X_train, Y_train)
    #####在验证集X_valid上给出预测结果 Y_pred_valid, 提示：model.test()
    Y_pred_valid = model.test(X_valid)
    #####计算验证集上的准确率
    acc_k = cal_accuracy(Y_pred_valid, Y_valid)
    #####将每个取值k对应的验证集准确率加入列表
    accs.append(acc_k)
    print('k={}, accuracy on validation={}%'.format(k, acc_k))

import matplotlib.pyplot as plt
plt.plot(possible_k_list, accs) #画出每个k对应的验证集准确率

k=1, accuracy on validation=96.5%
k=3, accuracy on validation=97.0%
k=5, accuracy on validation=96.875%
k=7, accuracy on validation=97.25%
k=9, accuracy on validation=97.0%
k=11, accuracy on validation=97.5%

在这里插入图片描述

#####基于上面的结果确定验证集上的最好的超参数k，根据这个k最终在测试集上进行测试
#####定义最好的k对应的模型
best_k = possible_k_list[np.argmax(accs)]
model = KNN_model(k=best_k)

#####在训练集上训练，注意这里可以使用全部的训练数据
model.train(X, Y)

#####在测试集上测试生成预测 Y_pred_test
Y_pred_test = model.test(X_test)
print('Test Accuracy={}%'.format(cal_accuracy(Y_pred_test, Y_test)))

Test Accuracy=97.05%

#####以下需要实现5折交叉验证，可以参考之前训练集和验证集划分的方式
folds = 5
for k in possible_k_list: # 遍历所有可能的k
    print('******k={}******'.format(k))
    valid_accs = []
    for i in range(folds): # 第i折的实验
        ##### 生成第i折的训练集 X_train_i, Y_train_i和验证集 X_valid_i, Y_valid_i; 提示：可参考之前random shuffle的方式来生成index
        np.random.shuffle(shuffle_index)
        fold_size = int(N/folds)
        test_start = i * fold_size
        test_end = min((i+1) * fold_size, N)
        valid_index_i, train_index_i = shuffle_index[test_start:test_end], np.concatenate([shuffle_index[:test_start], shuffle_index[test_end:]])
        X_valid_i, Y_valid_i = X[valid_index_i], Y[valid_index_i]
        train_index_i = list(map(int, train_index_i))
        X_train_i, Y_train_i = X[train_index_i], Y[train_index_i]
        
        ##### 定义超参数设置为k的模型
        model = KNN_model(k=k)

        ##### 在Fold-i上进行训练
        model.train(X_train_i, Y_train_i)

        ##### 给出Fold-i验证集X_valid_i上的预测结果 Y_pred_valid_i
        Y_pred_valid_i = model.test(X_valid_i)
        acc = cal_accuracy(Y_pred_valid_i, Y_valid_i)
        valid_accs.append(acc)
        print('Valid Accuracy on Fold-{}: {}%'.format(i+1, acc))
    print('k={}, Accuracy {}+-{}%'.format(k, np.mean(valid_accs), np.std(valid_accs)))

k=1
Valid Accuracy on Fold-1: 95.625%
Valid Accuracy on Fold-2: 95.375%
Valid Accuracy on Fold-3: 96.0%
Valid Accuracy on Fold-4: 97.0%
Valid Accuracy on Fold-5: 96.0%
k=1, Accuracy 96.0±0.5533985905294664%
k=3
Valid Accuracy on Fold-1: 96.5%
Valid Accuracy on Fold-2: 97.0%
Valid Accuracy on Fold-3: 96.625%
Valid Accuracy on Fold-4: 96.5%
Valid Accuracy on Fold-5: 95.625%
k=3, Accuracy 96.45±0.4513867521316947%
k=5
Valid Accuracy on Fold-1: 96.625%
Valid Accuracy on Fold-2: 97.125%
Valid Accuracy on Fold-3: 96.75%
Valid Accuracy on Fold-4: 96.5%
Valid Accuracy on Fold-5: 97.0%
k=5, Accuracy 96.8±0.2318404623873926%
k=7
Valid Accuracy on Fold-1: 96.375%
Valid Accuracy on Fold-2: 96.5%
Valid Accuracy on Fold-3: 97.375%
Valid Accuracy on Fold-4: 95.875%
Valid Accuracy on Fold-5: 96.125%
k=7, Accuracy 96.45±0.5099019513592785%
k=9
Valid Accuracy on Fold-1: 96.875%
Valid Accuracy on Fold-2: 96.75%
Valid Accuracy on Fold-3: 97.125%
Valid Accuracy on Fold-4: 96.875%
Valid Accuracy on Fold-5: 95.875%
k=9, Accuracy 96.7±0.4301162633521313%
k=11
Valid Accuracy on Fold-1: 97.25%
Valid Accuracy on Fold-2: 97.0%
Valid Accuracy on Fold-3: 96.625%
Valid Accuracy on Fold-4: 96.875%
Valid Accuracy on Fold-5: 96.625%
k=11, Accuracy 96.875±0.23717082451262844%

#####基于交叉验证确定验证集上的最好的超参数k，根据这个k最终在测试集上进行测试
#####定义最好的k对应的模型
best_k = possible_k_list[np.argmax(np.mean(valid_accs))]
model = KNN_model(k=best_k)

#####在训练集上训练，注意这里可以使用全部的训练数据
model.train(X, Y)

#####在测试集上测试生成预测 Y_pred_test
Y_pred_test = model.test(X_test)
print('Test Accuracy chosing k using cross-validation={}%'.format(cal_accuracy(Y_pred_test, Y_test)))

Test Accuracy chosing k using cross-validation=100.0%

#####如果训练/测试集不均衡如果评估模型呢？
#####生成一个不均衡的测试集，由于示例数据集中所有的标签1都在后面所以出于方便直接这样来生成一个不均衡的测试集
N_test = int(X_test.shape[0]*0.7)
X_test, Y_test = X_test[:N_test], Y_test[:N_test]
print(Counter(Y_test)) # 输出新的测试集中的标签分布

model = KNN_model(k=best_k) # 此处请填入交叉验证确定的最好的k
model.train(X, Y)
Y_pred_test = model.test(X_test)

#实现计算percision， recall和F1 score的函数
from sklearn.metrics import precision_recall_fscore_support
def cal_prec_recall_f1(Y_pred, Y_gt):
    '''
    Input: predicted labels y_pred, ground truth labels Y_gt
    Return: precision, recall, and F1 score
    '''
    precision, recall, f1, _ = precision_recall_fscore_support(Y_gt, Y_pred, average='binary')
    return precision, recall, f1
    
print(cal_prec_recall_f1(Y_pred_test, Y_test))

Counter({0: 2000, 1: 800})
(1.0, 1.0, 1.0)

作业五

请用python代码实现：

已知正例点 x 1 = ( 1 , 2 ) T , x 2 = ( 2 , 3 ) T , x 3 = ( 3 , 3 ) T x_1 =(1,2)^T,x_2=(2,3)^T,x_3=(3,3)^T x1​=(1,2)T,x2​=(2,3)T,x3​=(3,3)T，负例点 x 4 = ( 2 , 1 ) T , x 5 = ( 3 , 2 ) T x_4=(2,1)^T,x_5=(3,2)^T x4​=(2,1)T,x5​=(3,2)T，用sklearn.svm的SVC类来求最大间隔分离平面和分类决策函数，并用matplotlib库画出分离超平面、间隔边界及支持向量。输出Python代码。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC

# 正例点
x1 = np.array([1, 2])
x2 = np.array([2, 3])
x3 = np.array([3, 3])

# 负例点
x4 = np.array([2, 1])
x5 = np.array([3, 2])

# 数据集
X = np.array([x1, x2, x3, x4, x5])
y = np.array([1, 1, 1, -1, -1])

# 创建SVC模型，使用线性核函数
model = SVC(kernel='linear')

# 拟合模型
model.fit(X, y)

# 获取分离超平面的系数
w = model.coef_[0]
slope = -w[0] / w[1]
b = model.intercept_[0]
x_min = min(X[:, 0]) - 1
x_max = max(X[:, 0]) + 1
y_min = min(X[:, 1]) - 1
y_max = max(X[:, 1]) + 1
xx = np.linspace(x_min, x_max, 100)
yy = slope * xx - (b / w[1])

# 画出分离超平面、间隔边界及支持向量
plt.plot(xx, yy, 'k-', label='Separating Hyperplane')
plt.plot(xx, yy + 1 / np.sqrt(np.sum(w ** 2)), 'k--', label='Margin Boundary')
plt.plot(xx, yy - 1 / np.sqrt(np.sum(w ** 2)), 'k--')
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired, label='Points')
plt.scatter(model.support_vectors_[:, 0], model.support_vectors_[:, 1], s=100, facecolors='none', edgecolors='k', label='Support Vectors')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.savefig('5.png',dpi=100)
plt.show()

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

优秀智慧园区案例 - 新华三未来工厂制造园，园区业务创新及零碳升级

优秀智慧园区案例 - 新华三未来工厂制造园，园区业务创新及零碳升级

目录 一、新华三未来工厂制造园建设背景 二、未来工厂制造园总体设计思路 三、未来工厂制造园建设内容 四、关键技术及创新点 五、应用效益与推广 关键词&#xff1a;智慧园区解决方案&#xff0c;智慧园区建设总体方案&#xff0c;智慧园区建设规划方案&#xff0c;智慧园…
阅读更多...
label

label

可以为input元素定义标注。点击label标签内文本时&#xff0c;浏览器自动将光标转到或选择对应表单元素上。 label中for属性应当与相关元素的id属性相同
阅读更多...
详述使用CubeMX配置STM32RCC时钟

详述使用CubeMX配置STM32RCC时钟

&#x1f64c;秋名山码民的主页 &#x1f602;oi退役选手&#xff0c;Java、大数据、单片机、IoT均有所涉猎&#xff0c;热爱技术&#xff0c;技术无罪 &#x1f389;欢迎关注&#x1f50e;点赞&#x1f44d;收藏⭐️留言&#x1f4dd; 获取源码&#xff0c;添加WX 目录 前言一…
阅读更多...
2013年01月16日 Go生态洞察：并发不是并行

2013年01月16日 Go生态洞察：并发不是并行

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…
阅读更多...
DBeaver clickhouse 时区不对 时间少了8小时,本人的有效，网上好多都是扯犊子

DBeaver clickhouse 时区不对 时间少了8小时,本人的有效，网上好多都是扯犊子

特别注意&#xff1a;use_time_zone Asia/Shanghai use_server_time_zone true
阅读更多...
知识竞赛中常用的物料有哪些

知识竞赛中常用的物料有哪些

办一场知识竞赛&#xff0c;需要准备的物料要根据具体竞赛规则和流程来定。但是要仔细分析起来&#xff0c;还是可以做一个常用物料清单的&#xff0c;下面我将知识竞赛活动中常用的物料做了一个分类和列表&#xff0c;大家以后在竞赛活动举办过程中&#xff0c;可以参考。 一、…
阅读更多...
单独设置echarts图例样式

单独设置echarts图例样式

参考&#xff1a;echarts-legend legend: [{data: [{name: 正常,icon: rect}],itemWidth: 16,itemHeight: 4,top: 6%,left: 35%,textStyle: {color: #626C78,fontSize: 14}},{data: [{name: 异常,icon: rect}],itemWidth: 16,itemHeight: 4,top: 6%,left: 50%,textStyle: {col…
阅读更多...
JavaScript数据类型和存储区别

JavaScript数据类型和存储区别

目录 一、原始数据类型 二、引用数据类型 三、存储区别 四、常见错误 JavaScript是一种动态类型语言&#xff0c;这意味着变量可以在程序执行过程中改变其数据类型。了解JavaScript中的数据类型和它们的存储方式对于编写高效和可维护的代码至关重要。 在JavaScript中&…
阅读更多...
苹果手机通话记录怎么恢复？这3个方法就足够！

苹果手机通话记录怎么恢复？这3个方法就足够！

通话记录是手机中的重要数据之一&#xff0c;它记录了用户与联系人的通话信息&#xff0c;包括通话时间、通话时长、通话号码等等。 有时候&#xff0c;我们可能不小心删除了通话记录&#xff0c;或者想找回之前的通话记录以此来回忆起一些事情。那么&#xff0c;苹果手机通话…
阅读更多...
基于安卓android微信小程序的快递取件及上门服务系统

基于安卓android微信小程序的快递取件及上门服务系统

项目介绍 本文从管理员、用户的功能要求出发&#xff0c;快递取件及上门服务中的功能模块主要是实现管理员服务端&#xff1b;首页、个人中心、用户管理、快递下单管理、预约管理、管理员管理、系统管理、订单管理&#xff0c;用户客户端&#xff1b;首页、快递下单、预约管理…
阅读更多...
电压放大器适合什么应用

电压放大器适合什么应用

电压放大器是电子电路中常见的一种放大器&#xff0c;广泛应用于各个领域。本文将详细介绍电压放大器的特点和适用的主要应用。 电压放大器具有放大信号的功能&#xff0c;可以将输入信号的幅度放大数倍或数十倍。这使得电压放大器在各种需要信号增强的应用中非常重要。以下是电…
阅读更多...
一寸证件照排版工具，在线将证件照排版在相纸上

一寸证件照排版工具，在线将证件照排版在相纸上

证件照是我们经常使用到的一种办事资料&#xff0c;考试报名和办理个人证件都是需要的&#xff0c;很多时候需要纸质照片&#xff0c;如果我们手头有打印机的话就很方便了&#xff0c;但相纸都是固定尺寸的例如5寸、6寸相纸&#xff0c;而数码证件照的尺寸则不固定&#xff0c;…
阅读更多...
isomorphic-fetch库代码示例

isomorphic-fetch库代码示例

isomorphic-fetch库的爬虫程序。 typescript // 引入isomorphic-fetch库 import fetch from isomorphic-fetch; // 设置 const proxy ; // 定义视频URL const url ; // 使用fetch获取视频数据 fetch(url, { method: GET, headers: { Accept: application/json, …
阅读更多...
手写模拟SpringBoot核心流程

手写模拟SpringBoot核心流程

文章目录 1、创建工程1.1、pom依赖 1、创建工程 创建一个工程&#xff0c;包含springboot和user两个module springboot模块&#xff0c;表示springboot框架的源码实现user包&#xff0c;表示用户业务系统&#xff0c;用来写业务代码来测试我们所模拟出来的SpringBoot 1.1、…
阅读更多...
2023超级详细微信小程序纯前台获取当前具体位置，地图上选点进行位置签到 计算签到距离

2023超级详细微信小程序纯前台获取当前具体位置，地图上选点进行位置签到 计算签到距离

前言&#xff1a; 为了解决不同板块获取位置以及取代三级联动的问题&#xff0c;当前进行研究微信小程序获取当前具体位置。 思路&#xff1a; 调用微信小程序中获取当前地理位置的方法&#xff0c;与设置地理位置的方法&#xff0c;通过、、、实现当前距离设置打卡地点的距离&…
阅读更多...
python数据结构与算法-02_数组和列表

python数据结构与算法-02_数组和列表

线性结构 本节我们从最简单和常用的线性结构开始&#xff0c;并结合 Python 语言本身内置的数据结构和其底层实现方式来讲解。 虽然本质上数据结构的思想是语言无关的&#xff0c;但是了解 Python 的实现方式有助于你避免一些坑。 我们会在代码中注释出操作的时间复杂度。 数…
阅读更多...
【Python基础】文件传输协议

【Python基础】文件传输协议

&#x1f308;欢迎来到Python专栏 &#x1f64b;&#x1f3fe;‍♀️作者介绍&#xff1a;前PLA队员 目前是一名普通本科大三的软件工程专业学生 &#x1f30f;IP坐标&#xff1a;湖北武汉 &#x1f349; 目前技术栈&#xff1a;C/C、Linux系统编程、计算机网络、数据结构、Mys…
阅读更多...
PyCharm鼠标控制字体缩放

PyCharm鼠标控制字体缩放

File->Settings->Keymap 右边搜索栏输入increase(放大)&#xff0c;可以看到下面出现increase Font Size(放大字体尺寸)&#xff0c;双击。 双击后出现几个选项&#xff0c;选择Add Mouse Shortcut,会出现一个页面给录入动作。 按住Ctrl同时鼠标向上滚动&#xff0c;该动…
阅读更多...
时间序列预测实战(十六)PyTorch实现GRU-FCN模型长期预测并可视化结果

时间序列预测实战(十六)PyTorch实现GRU-FCN模型长期预测并可视化结果

往期回顾&#xff1a;时间序列预测专栏——包含上百种时间序列模型带你从入门到精通时间序列预测 一、本文介绍 本文讲解的实战内容是GRU-FCN(门控循环单元-全卷积网络)&#xff0c;这是一种结合了GRU&#xff08;用于处理时间序列数据&#xff09;和FCN&#xff08;全卷积网络…
阅读更多...
Java项目开发：基于Springboot+vue口腔牙科诊所管理系统

Java项目开发：基于Springboot+vue口腔牙科诊所管理系统

项目介绍 本选题则旨在通过标签分类管理等方式&#xff0c;实现管理员&#xff1a;首页、个人中心、会员管理、病例就诊信息管理、牙齿保健产品管理、复查提醒管理、预约挂号管理、药品信息管理、留言板管理、系统管理、订单管理&#xff0c;会员&#xff1b;首页、个人中心、…
阅读更多...
最新文章

Copyright @ 2022~2023