4-1封装器法

最新推荐文章于 2024-05-20 00:00:17 发布
最新推荐文章于 2024-05-20 00:00:17 发布
阅读量490 收藏 5
点赞数
分类专栏： CH3-数据准备和特征工程 文章标签： python 机器学习 开发语言 数据挖掘 数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46227276/article/details/124929570
版权

封装器法

请参考《数据准备和特征工程》中的相关章节，调试如下代码。

注意：本部分代码因为耗费的内存较大，在线执行如果不成功，请下载到本地执行。

4.1.1 循序特征选择

基础知识
# !mkdir /home/aistudio/external-libraries
# !pip install -i https://pypi.tuna.tsinghua.edu.cn/simple mlxtend -t /home/aistudio/external-libraries

import sys
sys.path.append('/home/aistudio/external-libraries')

from mlxtend.feature_selection import SequentialFeatureSelector as SFS
from sklearn.neighbors import KNeighborsClassifier
from mlxtend.data import wine_data
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = wine_data()
X.shape

(178, 13)

# stratify=y：对训练集和测试集按照标签y进行划分
X_train, X_test, y_train, y_test= train_test_split(X, y, 
                                                   stratify=y,
                                                   test_size=0.3,
                                                   random_state=1)
# 特征标准化
std = StandardScaler()
X_train_std = std.fit_transform(X_train)

# 创建knn模型，作为SFS(封装器)的目标函数：estimator=knn
# k_features=4：选择4个最佳特征
# forward=True：True代表循序向前特征选择
# floating=False：若为True，则启用浮动选择算法
# verbose=2：表示输出训练过程的全部日志信息，0为不显示，1为只显示1个
# scoring='accuracy'：对模型的评估方法
# cv=0：0为不进行交叉验证，默认值是5，表示要进行交叉验证，将训练集分为5份：训练4份，验证1份

knn = KNeighborsClassifier(n_neighbors=3)    
sfs = SFS(estimator=knn,     
           k_features=4,
           forward=True, 
           floating=False, 
           verbose=2,
           scoring='accuracy',
           cv=0)
sfs.fit(X_train_std, y_train)

[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  13 out of  13 | elapsed:    0.1s finished

[2022-05-22 11:00:12] Features: 1/4 -- score: 0.8629032258064516[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  12 out of  12 | elapsed:    0.0s finished

[2022-05-22 11:00:12] Features: 2/4 -- score: 0.9596774193548387[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  11 out of  11 | elapsed:    0.0s finished

[2022-05-22 11:00:13] Features: 3/4 -- score: 0.9919354838709677[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  10 out of  10 | elapsed:    0.0s finished

[2022-05-22 11:00:13] Features: 4/4 -- score: 0.9838709677419355


SequentialFeatureSelector(clone_estimator=True, cv=0,
                          estimator=KNeighborsClassifier(algorithm='auto',
                                                         leaf_size=30,
                                                         metric='minkowski',
                                                         metric_params=None,
                                                         n_jobs=None,
                                                         n_neighbors=3, p=2,
                                                         weights='uniform'),
                          fixed_features=None, floating=False, forward=True,
                          k_features=4, n_jobs=1, pre_dispatch='2*n_jobs',
                          scoring='accuracy', verbose=2)

# 返回每次选择出来的特征名称feature_names，及其相应的评估分数avg_score
sfs.subsets_

{1: {'feature_idx': (6,),
  'cv_scores': array([0.86290323]),
  'avg_score': 0.8629032258064516,
  'feature_names': ('6',)},
 2: {'feature_idx': (6, 9),
  'cv_scores': array([0.95967742]),
  'avg_score': 0.9596774193548387,
  'feature_names': ('6', '9')},
 3: {'feature_idx': (6, 9, 11),
  'cv_scores': array([0.99193548]),
  'avg_score': 0.9919354838709677,
  'feature_names': ('6', '9', '11')},
 4: {'feature_idx': (6, 8, 9, 11),
  'cv_scores': array([0.98387097]),
  'avg_score': 0.9838709677419355,
  'feature_names': ('6', '8', '9', '11')}}
项目案例
# SFFS：循序向前浮动选择
knn = KNeighborsClassifier(n_neighbors=3)
sfs1 = SFS(estimator=knn,     
           k_features=4,
           forward=True, 
           floating=True,     # SFFS
           verbose=2,
           scoring='accuracy',
           cv=0)
sfs.fit(X_train_std, y_train)

[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  13 out of  13 | elapsed:    0.1s finished

[2022-05-22 11:00:13] Features: 1/4 -- score: 0.8629032258064516[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  12 out of  12 | elapsed:    0.0s finished

[2022-05-22 11:00:13] Features: 2/4 -- score: 0.9596774193548387[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  11 out of  11 | elapsed:    0.0s finished

[2022-05-22 11:00:13] Features: 3/4 -- score: 0.9919354838709677[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  10 out of  10 | elapsed:    0.0s finished

[2022-05-22 11:00:13] Features: 4/4 -- score: 0.9838709677419355


SequentialFeatureSelector(clone_estimator=True, cv=0,
                          estimator=KNeighborsClassifier(algorithm='auto',
                                                         leaf_size=30,
                                                         metric='minkowski',
                                                         metric_params=None,
                                                         n_jobs=None,
                                                         n_neighbors=3, p=2,
                                                         weights='uniform'),
                          fixed_features=None, floating=False, forward=True,
                          k_features=4, n_jobs=1, pre_dispatch='2*n_jobs',
                          scoring='accuracy', verbose=2)

from mlxtend.plotting import plot_sequential_feature_selection as plot_sfs

# plot_sfs?

%matplotlib inline
from mlxtend.plotting import plot_sequential_feature_selection as plot_sfs

# 绘制特征子集与模型评分之间的关系图
# get_metric_dict()：以字典的方式返回：knn模型对特征子集的各个特征组合进行评估的结果
# kind='std_err'：{'std_dev'、'std_err'、'ci'、None} 中的误差线或置信区间。

fig = plot_sfs(sfs.get_metric_dict(), kind='std_err')

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-coeXT1yZ-1653294190061)(https://s2.loli.net/2022/05/23/6jGhMIH81fxcbke.png)]

sfs.get_metric_dict()

{1: {'feature_idx': (6,),
  'cv_scores': array([0.86290323]),
  'avg_score': 0.8629032258064516,
  'feature_names': ('6',),
  'ci_bound': nan,
  'std_dev': 0.0,
  'std_err': nan},
 2: {'feature_idx': (6, 9),
  'cv_scores': array([0.95967742]),
  'avg_score': 0.9596774193548387,
  'feature_names': ('6', '9'),
  'ci_bound': nan,
  'std_dev': 0.0,
  'std_err': nan},
 3: {'feature_idx': (6, 9, 11),
  'cv_scores': array([0.99193548]),
  'avg_score': 0.9919354838709677,
  'feature_names': ('6', '9', '11'),
  'ci_bound': nan,
  'std_dev': 0.0,
  'std_err': nan},
 4: {'feature_idx': (6, 8, 9, 11),
  'cv_scores': array([0.98387097]),
  'avg_score': 0.9838709677419355,
  'feature_names': ('6', '8', '9', '11'),
  'ci_bound': nan,
  'std_dev': 0.0,
  'std_err': nan}}

# 改进做法：k_features=(3, 10)设置特征数量的范围，在该范围中找出最佳个数的特征
knn = KNeighborsClassifier(n_neighbors=3)
sfs2 = SFS(estimator=knn,     
           k_features=(3, 10),
           forward=True, 
           floating=True,   
           verbose=0,
           scoring='accuracy',
           cv=5)
sfs2.fit(X_train_std, y_train)
fig = plot_sfs(sfs2.get_metric_dict(), kind='std_err')

png

# 由图查看最佳特征数量为6个，查看详细信息
sfs2.subsets_[6]

{'feature_idx': (0, 3, 6, 9, 10, 12),
 'cv_scores': array([0.96, 1.  , 1.  , 1.  , 1.  ]),
 'avg_score': 0.992,
 'feature_names': ('0', '3', '6', '9', '10', '12')}
动手练习
import pandas as pd

df = pd.read_csv("data/data20528/housprice.csv")
df.shape
df.head()
IdMSSubClassMSZoningLotFrontageLotAreaStreetAlleyLotShapeLandContourUtilities...PoolAreaPoolQCFenceMiscFeatureMiscValMoSoldYrSoldSaleTypeSaleConditionSalePrice
0160RL65.08450PaveNaNRegLvlAllPub...0NaNNaNNaN022008WDNormal208500
1220RL80.09600PaveNaNRegLvlAllPub...0NaNNaNNaN052007WDNormal181500
2360RL68.011250PaveNaNIR1LvlAllPub...0NaNNaNNaN092008WDNormal223500
3470RL60.09550PaveNaNIR1LvlAllPub...0NaNNaNNaN022006WDAbnorml140000
4560RL84.014260PaveNaNIR1LvlAllPub...0NaNNaNNaN0122008WDNormal250000

5 rows × 81 columns

# 讲数据类型为'int64', 'float64'的特征列挑选出来组成新的数据集data
cols = list(df.select_dtypes(include=['int64', 'float64']).columns)  
data = df[cols]
print(data.shape)
data.head()

(1460, 38)
IdMSSubClassLotFrontageLotAreaOverallQualOverallCondYearBuiltYearRemodAddMasVnrAreaBsmtFinSF1...WoodDeckSFOpenPorchSFEnclosedPorch3SsnPorchScreenPorchPoolAreaMiscValMoSoldYrSoldSalePrice
016065.084507520032003196.0706...0610000022008208500
122080.0960068197619760.0978...29800000052007181500
236068.0112507520012002162.0486...0420000092008223500
347060.0955075191519700.0216...035272000022006140000
456084.0142608520002000350.0655...1928400000122008250000

5 rows × 38 columns

# 将特征'SalePrice'作为标签列(labels)
X_train,X_test,y_train,y_test=train_test_split(data.drop('SalePrice',axis=1),data['SalePrice'],test_size=.2,random_state=1)
X_train.fillna(0, inplace=True)    # 用0填充缺失值
from sklearn.ensemble import RandomForestRegressor

# 将随机森林回归模型作为SFS的目标函数
sfs3 = SFS(RandomForestRegressor(),    
           k_features=10,
           forward=True,
           verbose=0,
           cv=5,
           n_jobs=-1,
           scoring='r2')
sfs3.fit(X_train,y_train)

# 挑选出来的10个最优特征
sfs3.k_feature_names_

('LotFrontage',
 'OverallQual',
 'YearRemodAdd',
 'MasVnrArea',
 'BsmtFinSF1',
 'TotalBsmtSF',
 'GrLivArea',
 'Fireplaces',
 'GarageCars',
 'OpenPorchSF')

4.1.2 穷举特征选择

基础知识
# 将通过SFS选择出来的10佳特征作为新的数据集
mini_data = X_train[X_train.columns[list(sfs3.k_feature_idx_)]]    
mini_data.shape

(1168, 10)

# from mlxtend.feature_selection import ExhaustiveFeatureSelector as EFS
# EFS?

import numpy as np
from mlxtend.feature_selection import ExhaustiveFeatureSelector as EFS

# EFS: 穷举特征选择来选出5强特征
# scoring='r2': （决定系数） 回归评分函数。
# n_jobs=-1: 并行数跟CPU核数一致。

efs = EFS(RandomForestRegressor(),
        min_features=1,
        max_features=5,
        scoring='r2',
        n_jobs=-1)    

efs.fit(np.array(mini_data),y_train)

# 将5强特征名进行输出
mini_data.columns[list(efs.best_idx_)]

Features: 637/637


Index(['OverallQual', 'YearRemodAdd', 'BsmtFinSF1', 'TotalBsmtSF',
       'GrLivArea'],
      dtype='object')
项目案例
import pandas as pd  
import numpy as np  

# 选取该数据集的前20000行样本
paribas_data = pd.read_csv("data/data20528/paribas_data.csv", nrows=20000)  
paribas_data.shape

(20000, 133)

# 通过数据类型来选择特征
num_colums = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']      
numerical_columns = list(paribas_data.select_dtypes(include=num_colums).columns)      

paribas_data = paribas_data[numerical_columns]  
paribas_data.shape

(20000, 114)

from sklearn.model_selection import train_test_split 

# 划分训练集：train_features和测试集：test_features
train_features, test_features, train_labels, test_labels = train_test_split(  
    paribas_data.drop(labels=['target', 'ID'], axis=1),
    paribas_data['target'],
    test_size=0.2, 
    random_state=41)

# correlated_features: 创建相关特征的空集合set()
correlated_features = set()  

# corr():表示两个变量之间的相关性，取值范围为[-1,1],取值接近-1，表示反相关，取值接近1，表正相关。
correlation_matrix = paribas_data.corr()         

# 将相关系数大于0.3的特征选择出来，加入到correlated_features集合中
for i in range(len(correlation_matrix.columns)):  
    for j in range(i):
        if abs(correlation_matrix.iloc[i, j]) > 0.3:   
            colname = correlation_matrix.columns[i]
            correlated_features.add(colname)

# 将上面选择出的correlated_features从数据集中删除。
train_features.drop(labels=correlated_features, axis=1, inplace=True)  
test_features.drop(labels=correlated_features, axis=1, inplace=True)

train_features.shape, test_features.shape

((16000, 10), (4000, 10))

from mlxtend.feature_selection import ExhaustiveFeatureSelector  
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier  
from sklearn.metrics import roc_auc_score

# EFS：穷举特征选择
feature_selector = ExhaustiveFeatureSelector(RandomForestClassifier(n_jobs=-1),   
           min_features=2,
           max_features=4,
           scoring='roc_auc',
           print_progress=True,
           cv=2)

# 通过EFS模型来进行特征选择
features = feature_selector.fit(np.array(train_features.fillna(0)), train_labels)  

# 最终得出2个最佳特征：'v10', 'v38'
filtered_features= train_features.columns[list(features.best_idx_)]  
filtered_features

Features: 375/375


Index(['v10', 'v38'], dtype='object')
动手练习
# 第2题
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from mlxtend.feature_selection import ExhaustiveFeatureSelector as EFS

iris = datasets.load_iris()
X = iris.data
y = iris.target

efs = EFS(RandomForestClassifier(n_jobs=-1),
          min_features=2, 
          max_features=4,
          print_progress=True,
          cv=2)

efs.fit(X, y)
efs.best_idx_

4.1.3 递归特征消除

基础知识
from sklearn.feature_selection import RFE

rfe = RFE(RandomForestRegressor(), n_features_to_select=5)  
rfe.fit(np.array(mini_data),y_train)

# 打印特征排名，1为权重最高的5个特征
print(rfe.ranking_)

print(mini_data.columns[rfe.ranking_==1])

[4 1 2 3 1 1 1 6 1 5]
Index(['OverallQual', 'BsmtFinSF1', 'TotalBsmtSF', 'GrLivArea', 'GarageCars'], dtype='object')
项目案例
import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder

df_train = pd.read_csv("data/data20528/train.csv")
df_test = pd.read_csv("data/data20528/train.csv")

# 统计训练集和测试集的样本行数
train_samples = df_train.shape[0]
test_samples = df_test.shape[0]

# 将训练集和测试集按行合并，忽视原索引，并使警告静音而不进行排序
train_test = pd.concat((df_train, df_test), axis=0, ignore_index=True, sort=False)

# 将特征集features划分为分类特征cat_features和数值特征num_features
features = [x for x in df_train.columns]
cat_features = [x for x in df_train.select_dtypes(include=['object']).columns]
num_features = [x for x in df_train.select_dtypes(exclude=['object']).columns]

print('\n 特征集个数: %d' % len(features))
print('\n 分类特征个数: %d' % len(cat_features))
print('\n 数值特征个数: %d\n' % len(num_features))

# 对分类特征的每一列进行标签编码LabelEncoder()，即数值化变换
le = LabelEncoder()
for c in cat_features:
    train_test[c] = le.fit_transform(train_test[c])

X_train = train_test.iloc[:train_samples, :].drop(['id', 'loss'], axis=1)
X_test = train_test.iloc[train_samples:, :].drop(['id'], axis=1)

 特征集个数: 132

 分类特征个数: 116

 数值特征个数: 16

from sklearn.feature_selection import RFECV
from sklearn.ensemble import RandomForestRegressor
from datetime import datetime

# 将loss值作为标签y_train
y_train = df_train['loss']

rfr = RandomForestRegressor(n_estimators=100, 
                            max_features='sqrt', 
                            max_depth=12, 
                            n_jobs=-1)
rfecv = RFECV(estimator=rfr,    
              step=10,
              cv=3,
              min_features_to_select=10,
              scoring='neg_mean_absolute_error',
              verbose=2)

start_time = datetime.now()
rfecv.fit(X_train, y_train)
end_time = datetime.now()

# 输出总的训练时间，m,s为divmod()计算后的商和余数
m, s = divmod((end_time - start_time).total_seconds(), 60)
print('训练时间花费为: {0} 分  {1} 秒'.format(m, round(s, 2)))

Fitting estimator with 130 features.
Fitting estimator with 120 features.
Fitting estimator with 110 features.
Fitting estimator with 100 features.
Fitting estimator with 90 features.
Fitting estimator with 80 features.
Fitting estimator with 70 features.
Fitting estimator with 60 features.
Fitting estimator with 50 features.
Fitting estimator with 40 features.
Fitting estimator with 30 features.
Fitting estimator with 20 features.
Fitting estimator with 130 features.
Fitting estimator with 120 features.
Fitting estimator with 100 features.
Fitting estimator with 90 features.
Fitting estimator with 80 features.
Fitting estimator with 70 features.
Fitting estimator with 60 features.
Fitting estimator with 50 features.
Fitting estimator with 40 features.
Fitting estimator with 30 features.
Fitting estimator with 20 features.
Fitting estimator with 130 features.
Fitting estimator with 120 features.
Fitting estimator with 110 features.
Fitting estimator with 100 features.
Fitting estimator with 90 features.
Fitting estimator with 80 features.
Fitting estimator with 70 features.
Fitting estimator with 60 features.
Fitting estimator with 50 features.
Fitting estimator with 40 features.
Fitting estimator with 30 features.
Fitting estimator with 20 features.
Fitting estimator with 130 features.
Fitting estimator with 120 features.
Fitting estimator with 100 features.
Fitting estimator with 90 features.
Fitting estimator with 80 features.
训练时间花费为: 4.0 分  37.94 秒

# 复制文件到matplotlib字体路径
!cp simhei.ttf /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/ttf/
# 删除matplotlib的缓冲目录
!rm -rf .cache/matplotlib
# 重启内核

%matplotlib inline
import matplotlib.pyplot as plt

# 设置显示中文
plt.rcParams['font.sans-serif'] = ['SimHei'] # 指定默认字体
plt.rcParams['axes.unicode_minus'] = False   # 解决保存图像是负号'-'显示为方块的问题

plt.figure()
plt.xlabel('测试的特征数量 x 10')
plt.ylabel('交叉验证分数 (负MAE)')

plt.plot(range(1, len(rfecv.grid_scores_) + 1), rfecv.grid_scores_)

png

# 将特征进行排序，并显示前10的特征
ranking = pd.DataFrame({'特征': features})
ranking.drop([0, 131], inplace=True)

ranking['排名'] = rfecv.ranking_
ranking.sort_values('排名', inplace=True)

ranking.head(10)
特征排名
1cat11
103cat1031
101cat1011
100cat1001
99cat991
94cat941
92cat921
91cat911
90cat901
89cat891
动手练习
# 第2题
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.model_selection import StratifiedKFold
from sklearn.feature_selection import RFECV
from sklearn.datasets import make_classification

# 创建数据集
X, y = make_classification(n_samples=1000, n_features=25, n_informative=3,
                           n_redundant=2, n_repeated=0, n_classes=8,
                           n_clusters_per_class=1, random_state=0)

# 创建RFEC
svc = SVC(kernel="linear")
rfecv = RFECV(estimator=svc, 
              step=1, 
              cv=StratifiedKFold(2),
              scoring='accuracy')
rfecv.fit(X, y)

print("最优特征数量: %d" % rfecv.n_features_)

# 制图
plt.figure()
plt.xlabel("选定的特征数量")
plt.ylabel("交叉验证分数(注意正确的分类)")

plt.plot(range(1, len(rfecv.grid_scores_) + 1), rfecv.grid_scores_)

最优特征数量: 3

png

绿洲213
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MV-LEVD-200-4-PY 海康微视光源控制器协议封装类
十多年IT经验,专注机器视觉,智能制造半导体行业
02-17 2454
1.输出电压脉冲的宽度（即光源的点亮时间）可设置 1us～999us,并可进行脉宽比例设置；4.可工作于外触发模式，按需要点亮光源；也可工作于内触发模式，按固定频率点亮光源；3.自动输出相机触发信号，并确保在光源点亮后同步触发相机采集图片；2.提升光源瞬间亮度达 400%以上，并延长光源使用寿命；#　海康微视光源控制器说明书。
VL53L4CD TOF开发(1)-驱动TOF进行测距
01-14
B站教学视频：https://www.bilibili.com/video/BV1ma4y117bQ/ VL53L4CD适用于接近测量和短距离测量，可实现从仅仅1 mm到1300 mm的超精准距离测量。新一代激光发射器具有18°视场 (FoV)，提高了环境光下的性能，其...
集成电路--封装种类
moqingxinai2008的专栏
12-04 1529
集成电路的封装种类 　　1、BGA(ball grid array) 　　球形触点陈列，表面贴装型封装之一。在印刷基板的背面按陈列方式制作出球形凸点用以代替引脚，在印刷基板的正面装配LSI芯片，然后用模压树脂或灌封方法进行密封。也称为凸点陈列载体(PAC)。引脚可超过200，是多引脚LSI用的一种封装。 封装本体也可做得比QFP(四侧引脚扁平封装)小。例如，引脚中心距为1.5mm 的360 引
ESD管SOD-523封装，常用型号有哪些？
DOWOSEMI13的博客
08-06 1548
客户在询ESD二极管过程中，大多都是根据封装、电压、结电容等参数来询料的，当然，也有客户直接带着ESD二极管型号来找替代物料。近日，由于新冠肺炎疫情的影响，国际品牌ESD物料交期变长，很多客户往往等不了那么长的交期，为此，国产ESD品牌成为了首选。那么，问题来了，ESD二极管国产替代，如何确认型号呢？ ESD国产替代料号的确认，第一要确认的是封装，优先匹配一样的封装，实现pin to pin直接替代。比如，ESD5B5.0ST1G（安森美ON），根据器产品规格书手册查看可知，ESD二极管ESD5.
【AD笔记】--封装库&PCB
Rendezvous1的博客
01-28 4999
绘制PCB封装库 方法一： 首先新建一个PCB元件库 以AMS1117为例，先从立创上找一个AMS1117的封装。 可以看到，一个基本的封装包括焊盘（红色方框的地方），和丝印（黄色的线）。焊盘就是我们焊板子的时候和元器件焊在一起的那片金属，丝印是板子上白色的线。 （回到画元件）首先先放置焊盘。 第一次点可能会出来一个奇怪的东西，我们可以按table键修改它的参数。依然是在properties里面。 Location是设置焊盘的坐标（这还蛮重要的，因为几个焊盘的相对位置非常重要），这里我们选择对着立创的
51单片机学习笔记4 -- 蜂鸣器控制
热门推荐
General_s
01-10 1万+
51单片机蜂鸣器控制（有源蜂鸣器）
STBC03 锂电池充电器解决方案-电路方案
04-21
该锂电池管理项目即STBC03 锂离子线性电池充电器解决方案，电路...采用覆晶法30、400μm脚距封装 最关键引脚上的坚固±4kV HBM、ESD保护 应用 智能手表和可穿戴设备 健身和医疗配件 锂离子和其他锂聚合物电池充电设备
电路CAD-实验报告.pdf
03-11
图 1 甲乙类放大电路 图 1 中的元件列表 序号 元件值 元件封装 元件名 说明 R1、R2 27k AXIAL0.3 RES2 R3、R4 5k AXIAL0.3 RES2 C1 10u RB-.2/.4 ELECTRO1 极性电容 C2 200u RB-.2/.4 ELECTRO1 极性电容 D1、D2 1N...
HGE_系列教材(1-9)
06-22
<4> 位图字体编辑器：运行通过系统中已经安装的字体来创建位图字体，你可以使用 图形编辑器来为位图字体添加额外的效果 HGE 系列教材（2） --- 安装 HGE 在HGE 的文档中有详细谈到如何安装的问题，这里讲一下VC6 ...
通信与网络中的DnPort RJ45 封装的嵌入式串口服务器
10-21
DnPort 嵌入式串口服务器是一个完整的网络解决方案，它内带RJ45 封装接口。 　这种微型串行到以太网转换器授权，原始设备制造商（ OEM ）能够快速，便捷地进入市场。 　DnPort 包含如下： 　1. 3.3 伏的串行接口...
【Python】Python中变量或者函数加下划线‘_‘的含义
yangweipeng708的博客
05-14 668
理解这些约定可以帮助Python开发者编写更清晰、更Pythonic的代码，并理解其他Python代码中的命名习惯。）通常用来指示特定的编程约定或用法，这些约定主要关乎变量和函数的可访问性以及预期的使用范围。在Python中，变量或函数前面加一个下划线（
python数据分析numpy基础之intersect1d求数组交集
sinat_34735632的博客
05-19 189
python的numpy库的intersect1d(x,y)函数，计算x和y的公共元素，并返回去重后的有序结果。相当于求两个数组中的交集，并且进行去重和排序。numpy.intersect1()查找两个数组的公共元素，并且返回去重后的有序结果。ar1，ar2：必选，列表、元组、数组；如果是多维则自动转一维数组；assume_unique：可选，bool，默认False，若为True则可以加快计算素材，此时ar1和ar2需为元素唯一的数组，否则结果不会去重；
windows11 Django环境安装
云深海阔专栏
05-15 148
3）在这个文件夹中使用manager.py和runserver命令运行开发 web 服务器。2）使用 django-admin 工具创建一个名为“mytestsite”的新框架站点。浏览器上访问http://localhost:800。2、windows10 虚拟环境设置。1、验证python和pip3环境。1）创建文件夹及项目目录。4）web浏览器上验证。3、安装Django。
python数据分析——时间序列
qq_74013365的博客
05-14 1987
时间序列是按照时间顺序排列的一系列随时间变化而变化的数据点或观测值。时间序列可以是离散的，例如每月的销售数据，也可以是连续的，例如气温和股票价格等。时间序列常用于预测和分析未来的趋势，例如经济增长、股票走势、天气变化等。时间序列分析是数据分析中的重要部分，它涉及到对随时间变化的数据进行研究，以揭示其内在规律、趋势和周期性变化。Python作为一种强大的编程语言，拥有众多的数据处理和可视化库，如pandasnumpymatplotlib和seaborn等，这些库在处理时间序列数据时表现出色。
Gradio 案例——将 dicom 文件转为 nii文件
蒋含竹的博客
05-15 354
Gradio 的WEB界面案例：利用 SimpleITK 库，将 dicom 文件转为 nii文件
【华为OD机试-C卷D卷-200分】 简易内存池【C++/Java/Python】
goldarmour的博客
05-14 159
请实现一个简易内存池,根据请求命令完成内存分配和释放。 内存池支持两种操作命令，REQUEST和RELEASE，其格式为： REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。 RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
Python slice() 使用方法及示例说明
ym62033的博客
05-15 191
处。
python EEL + vue3.js 简单示例
bigcarp的专栏
05-15 185
eel官方示例中暴露的js函数是全局函数，vue中的自定义函数作用域通常都是组件范围内。要让eel.js调用，需要将其升为全局可用。一般方法有 app.config.globalProperties 或 mixin等。
用python进行“个税计算”
最新发布
算法与编程之美
05-20 68
1 问题企业发放的奖金根据利润来提成。利润(I)低于或等于5万元时，奖金可提10%；利润高于5万元，低于20万元时，低于5万元的部分按10%提成，高于5万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键...
stm32f40x原理图封装
06-26
STM32F40x系列是意法半导体推出的一系列高性能微控制器，封装形式有LQFP、BGA等。原理图封装是指将芯片的引脚和其他元器件连接的形式整合成一个封装元件，使得原理图上的元件可以与PCB上的元件一一对应。STM32F40x...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

绿洲213

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值