Competition Learning

基本方法

竞赛思路步骤

观察训练集和测试集的数据分布

库函数的使用

sklearn

安装依赖： pip install scikit-learn

datasets

 from sklearn import datasets
 
pixel_values, targets = datasets.load_digits(return_X_y=True)

manifold

 from sklearn import manifold
 
# t-SNE: 数据降维方法
# n_components: 降维后的维度
tsne = manifold.TSNE(n_components=2, random_state=42)
transformed_data = tsne.fit_transform(pixel_values[:1000, :])
# <transformed_data> = tsne.transform(<data>)

model_selection

标准 K-Fold 交叉验证

 import pandas as pd
from sklearn import model_selection
 
df = pd.read_csv("data/train.csv")  # 读取数据
 
# 我们创建一个名为 kfold 的新列，并用 -1 填充
df["kfold"] = -1
# 随机打乱数据的行
df = df.sample(frac=1).reset_index(drop=True)
 
# 从 model_selection 模块初始化 kfold 类
kf = model_selection.KFold(n_splits=5)
 
# 填充新的 kfold 列（enumerate的作用是返回一个迭代器）
for fold, (trn_, val_) in enumerate(kf.split(X=df)):
    df.loc[val_, 'kfold'] = fold
 
# 保存带有 kfold 列的新 CSV 文件
df.to_csv("data/train_folds.csv", index=False)

分层 K-Fold 交叉验证

 import pandas as pd
from sklearn import model_selection
 
df = pd.read_csv("data/train.csv")
 
# 添加一个新列 kfold，并用 -1 初始化
df["kfold"] = -1
# 随机打乱数据行
df = df.sample(frac=1).reset_index(drop=True)
 
# 获取目标变量（根据该变量的值所占比例来进行分层抽取）
y = df['quality'].values
 
# 初始化 StratifiedKFold 类，设置折数（folds）为 5
kf = model_selection.StratifiedKFold(n_splits=5)
 
# 使用 StratifiedKFold 对象的 split 方法来获取训练和验证索引
for f, (t_, v_) in enumerate(kf.split(X=df, y=y)):
    df.loc[v_, 'kfold'] = f
 
# 保存包含 kfold 列的新 CSV 文件
df.to_csv("data/train_stratified_folds.csv", index=False)

seaborn

可视化库函数

Pandas

API reference

读取数据

 import pandas as pd
 
df = pd.read_csv('xxx.csv')
# df = pd.read_excel(file_path)
df.head(10)  # 只展示前10条数据
df.to_numpy(dtype=<type>)  # 将df数据转换成numpy数据

数据填充

处理数据中存在缺失值的情况

 pd.get_dummies(df, dummy_na=True)  # 将类别值转换成one-hot vector

数据筛选

 # 根据指定列的值来筛选数据
df_raw[df_raw['col_name'] == query_val]
# 另
df_raw.query('col_name == query_val')

数据处理

map

使用一个映射字典，将表数据 df中的值全部映射为字典中对应的值

 # 一个映射字典，用于将质量值从 0 到 5 进行映射
quality_mapping = {
 3: 0,
 4: 1,
 5: 2,
 6: 3,
 7: 4,
 8: 5
}
 
# 你可以使用 pandas 的 map 函数以及任何字典，
# 来转换给定列中的值为字典中的值
df.loc[:, "quality"] = df.quality.map(quality_mapping)

sample

 # 从df中随机采样，frac表示采样的比例，frac=1相当于将df中的数据进行reshuffle
# drop=True 表示不向数据中插入新的列 index
df.sample(frac=1.0).reset_index(drop=True)

数据可视化（绘图）

 df_raw['col_name'].value_counts()  # 对`col_name`列的值统计数量
ax = df_raw['col_name'].plot(
    kind='hist',  # 绘制直方图
    bins=20,  # 直方图中柱的个数
    color='blue',
    figsize=(12, 8),
    fontsize=15
)
'''
ax.set_ylabel('x_label', fontsize = 15)
ax.set_xlabel('y_label', fontsize = 15)
'''

1711515780804

PyTorch

Foundation

@ : 矩阵乘法

 a = torch.ones((2, 3))
b = torch.ones((3, 4))
a @ b  # torch.Size([2, 4])

masked_fill(torch.bool, fill_val) : 掩码操作

 t.masked_fill(mask == 0, -10000)
# 将`mask`中值为0的位置对应的`t`的值设置为-10000

unsqueeze(dim: int) : 扩充张量的维度

 a = torch.ones((1, 2))
a = a.unsqueeze(0) # torch.Size([1, 1, 2])

transpose(dim1, dim2) : 交换张量指定两个维度的值

 a.transpose(2, 3)  # 交换张量`a`的第3、4维数据

permute(dim1, dim2, ...) : 重新更换张量的维度

 a.permute(1, 0, 2)  # 将张量`a`的维度分布更换成(1, 0, 2)

view(dim1, dim2, ...) : 重新分配张量每个维度的分布

 a.ones(2, 4, 5)
a = a.view(2, 2, 2, 5)  # torch.Size([2, 2, 2, 5])

contiguous() : 确保张量在内存中是连续存储的，可以提高性能，一般放在 transpose操作之后，view操作之前

 a.ones(2, 3, 4)
a.transpose(1, 0).contiguous().view(4, 2, 3)  # torch.Size([4, 2, 3])

 import torch
import torchvision  # 获取训练数据的函数
from torch.utils import data  # 读取训练数据的函数
from torchvision import transforms  # 转换训练数据的函数
 
torchvision.datasets.FashionMNIST?
torchvision.datasets.xxx  # 从官方网站获取训练数据
 
data.DataLoader(train, batch_size=xxx)  # 将数据转换为iterator
 
loss = nn.CrossEntropyLoss()  # 定义损失函数为交叉熵损失函数
updater = torch.optim.SGD(net.parameters(), lr=0.1)  # 定义优化器为随机梯度下降算法（步长为0.1）

Set Random Seed

 import numpy as np
import torch
import random
 
def same_seeds(seed):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.benchmark = False
    torch.backends.cudnn.deterministic = True

Train

 # 训练基本框架
net.train()
for epoch in range(num_epochs):
    for X, y in train_loader:
        optimizer.zero_grads()  # 梯度清零
	pred = net(y)
        loss = criterion(pred, y)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 优化

Validation

 model.eval()
loss_record = []
for x, y in valid_loader:
    x, y = x.to(device), y.to(device)
    with torch.no_grad():
        pred = model(x)
        loss = criterion(pred, y)
    loss_record.append(loss.detach().item())

Model

 class My_Model(nn.Module):
    def __init__(self):
        super().__init__()
	# define some layers
   
    def forward(self, x):
	# do something
        return x

Loss

 # Method 1: define a function
def my_loss(pred, target):
    loss = torch.mean((pred - target) ** 2)  # MSE
    return loss
 
# Method 2: define a nn.Module
class MSELoss(nn.Module):
    def __init__(self):
        super().__init__()
  
    def forward(self, inputs, targets):
        loss = torch.mean((pred - target) ** 2) 
        return loss
 
class DiceLoss(nn.Module):
    def __init__(self,weight=None,size_average=True):
        super(DiceLoss,self).__init__()
  
    def forward(self,inputs,targets,smooth=1):
        inputs = F.sigmoid(inputs)   
        inputs = inputs.view(-1)
        targets = targets.view(-1)
        intersection = (inputs * targets).sum()             
        dice = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)  
        return 1 - dice

LR_Scheduler

 net.train()
for epoch in range(num_epochs):
    train_step(...)
    val_step(...)
    lr_scheduler.step()

torchvision

use pre-trained model

 import torchvision.models as models
 
model = models.resnet18(pretrained=True)  # 使用ImageNet上的预训练权重（输出为1000类）
for param in model.parameters():  # 冻结参数的梯度
    param.requires_grad = False
# 修改模型
num_ftrs = model.fc.in_features
model.fc = nn.Linear(in_features=num_ftrs, out_features=4, bias=True)

timm

Install

 pip install timm

 import timm
 
avail_models = timm.list_models()  # list all available models
timm.list_models('*densenet*')  # search model with filter
 
model = timm.create_model('densenet121', pretrained=True)  # create pretrained model

torchinfo

 pip install torchinfo

 from torchinfo import summary
from torchvision import models
import torch
 
model = models.resnet18()
summary(model, (1, 3, 224, 224))
"""
def summary(net: nn.Module, input_size: tuple)
"""

Keras

Image

 dataset_dir = 'F:/datasets/dogs-vs-cats/'
batch_size = 8
image_size = (256, 256)
# 从指定文件夹中读取已经整理好的图片数据
train_ds, val_ds = utils.image_dataset_from_directory(
    dataset_dir,
    label_mode='binary',
    batch_size=batch_size,
    image_size=image_size,
    validation_split=0.1,  # split 10% for validation
    subset='both'  # return -> tuple(train_ds, val_ds)
)

Using pre-train model

 from keras.applications import VGG16
 
# 使用VGG16预定义模型（include_top=False时表示不包含最后的全连接层）
conv_base = VGG16(weights='imagenet', include_top=False, input_shape=(256, 256, 3))
model = models.Sequential([
    conv_base,  # 将预定义模型作为新模型的中间层
    layers.Flatten(),
    layers.Dense(256, activation='relu'),
    layers.Dense(1, activation='sigmoid')  # 数值回归
])
conv_base.trainable = False  # 冻结卷积基
# train the model
history = model.fit(train_ds, epochs=10, validation_data=val_ds)

Sequence

 from keras.preprocessing.text import Tokenizer
 
samples = ['The cat sat on the mat.', 'The dog ate my homework.']  # sequence list
 
tokenizer = Tokenizer(num_words=1000)
 
tokenizer.fit_on_texts(samples)
 
sequences = tokenizer.texts_to_sequences(samples)  # 按照samples中的所有词排序的index（这种方式进行数据处理更省内存）
one_hot_results = tokenizer.texts_to_matrix(samples, mode='binary')
 
word_index = tokenizer.word_index  # 按照samples中的所有词排序的index

Paddle

 import paddle
import paddle.nn as nn

t.reshape(<new_shape>)

t.unsqueeze(-1)：在张量最后一维添加一个新的维度

t.traspose([axis1, axis2,...])：更换张量中的轴的顺序

t.chunk(3, axis)：将张量的轴 axis均匀切分3份

API文档：https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle

Python语法

help doc

print(dir(<obj_name>)) : 获取对象<obj_name>中的所有方法名

print(help(<obj_name>)) : 获取对象<obj_name>的帮助文档

<obj_name>/<function_name>? : jupyter notebook中查看函数解释文档

native function

idx = slice([start], stop[,step]) : 获取数组切片

arr[idx] : 可以将slice对象传入数组中所有数组切片

float('inf') : python中的infinity

re

os

os.makedirs(<dir>, exist_ok=True) : create a new directory, skip if exists

当父目录不存在时会递归创建所有的目录

os.path.join(<parent_dir>, <child_dir>, <grandchild_dir>, ...) : concat the path of directory/file

os.path.splitext(<file_path>) : split the full path of file by . => (dir, ext)

os.scandir(directory)-> List[DirEntry] ：返回的是DirEntry对象的数组

DirEntry对象中的属性和方法：

name：文件名（路径名）

is_dir() -> bool

is_file() -> bool

shutil

import shutil

shutil.move(src_path, dest_path)：移动文件

shutil.copy(src_path, dest_path)：复制文件

matplotlib

import matplotlib.pyplot as plt ：导入绘图包

plt.plot(x_arr, y_arr, label='', linestyle='')：绘图

plt.legend()：将多个图形绘制在一个坐标系里面（用不同颜色区别）

plt.show()：最后显示图像

np.arange(start, end, step)

pickle

 import pickle
 
# 保存本地.pkl文件
data = xxx  # 创建data数据对象
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f)  # 将data数据对象保存到本地pkl文件
  
# 读取本地.pkl文件
with open('data.pkl', 'rb') as f:
    pickle.load(f)
  
# 注：文件读取和写入都是二进制格式

numpy

np.random.choice([start], end, num)：从start到end中随机抽取num个数

np.dot(v1, v2)：求两个向量的点积（向量积，结果仍为向量）

np.multiply(v1, v2)：求两个矩阵的哈达玛积（相对应元素的乘积）

pandas

df.dtypes[expre] : 获取满足expre表达式的索引数组

pd.get_dummies(df, dummy_na=True|False) : 将df中的标签列转换为one-hot-vector样式

tqdm

from tqdm import tqdm, trange

for i in tqdm(range(num_epochs))

for i in trange(num_epochs)

Python生成器

可以通过 for ... in ... 来进行访问

 def generator():
    i = 0
	while 1:
    	i += 1
        yield i
  
for j in generator():
    print(j)
    if j >= 4:
        break

wandb

Quickstart

首先使用命令 wandb login进行登录

在项目中添加下面代码初始化wandb：

 wandb.init(
        project="paper-sharing-dla",  # project name
        config={  # 配置信息
            "architecture": "ResNet-34",
            "dataset": "CIFAR-10",
            "epochs": 100,
        },
        name='resnet-34-with-data-augmentation'  # 默认随机生成两个单词组成的名称
    )

写入日志信息：

 wandb.log({  # 写入日志信息
    'loss': loss,
    'acc': acc
})

posted @ 2025-01-15 10:49 MaximeSHE 阅读(7) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Deep Learning

· Machine Learning

· PyImgSearch-博客中文翻译-九-

· 五、数据挖掘流程简明笔记

· 装甲板CNN试题

公告

昵称： MaximeSHE
园龄： 3年7个月
粉丝： 2
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

	from sklearn import datasets

	pixel_values, targets = datasets.load_digits(return_X_y=True)

	from sklearn import manifold

	# t-SNE: 数据降维方法
	# n_components: 降维后的维度
	tsne = manifold.TSNE(n_components=2, random_state=42)
	transformed_data = tsne.fit_transform(pixel_values[:1000, :])
	# <transformed_data> = tsne.transform(<data>)

	import pandas as pd
	from sklearn import model_selection

	df = pd.read_csv("data/train.csv") # 读取数据

	# 我们创建一个名为 kfold 的新列，并用 -1 填充
	df["kfold"] = -1
	# 随机打乱数据的行
	df = df.sample(frac=1).reset_index(drop=True)

	# 从 model_selection 模块初始化 kfold 类
	kf = model_selection.KFold(n_splits=5)

	# 填充新的 kfold 列（enumerate的作用是返回一个迭代器）
	for fold, (trn_, val_) in enumerate(kf.split(X=df)):
	df.loc[val_, 'kfold'] = fold

	# 保存带有 kfold 列的新 CSV 文件
	df.to_csv("data/train_folds.csv", index=False)

	import pandas as pd
	from sklearn import model_selection

	df = pd.read_csv("data/train.csv")

	# 添加一个新列 kfold，并用 -1 初始化
	df["kfold"] = -1
	# 随机打乱数据行
	df = df.sample(frac=1).reset_index(drop=True)

	# 获取目标变量（根据该变量的值所占比例来进行分层抽取）
	y = df['quality'].values

	# 初始化 StratifiedKFold 类，设置折数（folds）为 5
	kf = model_selection.StratifiedKFold(n_splits=5)

	# 使用 StratifiedKFold 对象的 split 方法来获取训练和验证索引
	for f, (t_, v_) in enumerate(kf.split(X=df, y=y)):
	df.loc[v_, 'kfold'] = f

	# 保存包含 kfold 列的新 CSV 文件
	df.to_csv("data/train_stratified_folds.csv", index=False)

	import pandas as pd

	df = pd.read_csv('xxx.csv')
	# df = pd.read_excel(file_path)
	df.head(10) # 只展示前10条数据
	df.to_numpy(dtype=<type>) # 将df数据转换成numpy数据

	# 根据指定列的值来筛选数据
	df_raw[df_raw['col_name'] == query_val]
	# 另
	df_raw.query('col_name == query_val')

	# 一个映射字典，用于将质量值从 0 到 5 进行映射
	quality_mapping = {
	3: 0,
	4: 1,
	5: 2,
	6: 3,
	7: 4,
	8: 5
	}

	# 你可以使用 pandas 的 map 函数以及任何字典，
	# 来转换给定列中的值为字典中的值
	df.loc[:, "quality"] = df.quality.map(quality_mapping)

	# 从df中随机采样，frac表示采样的比例，frac=1相当于将df中的数据进行reshuffle
	# drop=True 表示不向数据中插入新的列 index
	df.sample(frac=1.0).reset_index(drop=True)

	df_raw['col_name'].value_counts() # 对`col_name`列的值统计数量
	ax = df_raw['col_name'].plot(
	kind='hist', # 绘制直方图
	bins=20, # 直方图中柱的个数
	color='blue',
	figsize=(12, 8),
	fontsize=15
	)
	'''
	ax.set_ylabel('x_label', fontsize = 15)
	ax.set_xlabel('y_label', fontsize = 15)
	'''

	a = torch.ones((2, 3))
	b = torch.ones((3, 4))
	a @ b # torch.Size([2, 4])

	t.masked_fill(mask == 0, -10000)
	# 将`mask`中值为0的位置对应的`t`的值设置为-10000

	a = torch.ones((1, 2))
	a = a.unsqueeze(0) # torch.Size([1, 1, 2])

	a.ones(2, 4, 5)
	a = a.view(2, 2, 2, 5) # torch.Size([2, 2, 2, 5])

	a.ones(2, 3, 4)
	a.transpose(1, 0).contiguous().view(4, 2, 3) # torch.Size([4, 2, 3])

	import torch
	import torchvision # 获取训练数据的函数
	from torch.utils import data # 读取训练数据的函数
	from torchvision import transforms # 转换训练数据的函数

	torchvision.datasets.FashionMNIST?
	torchvision.datasets.xxx # 从官方网站获取训练数据

	data.DataLoader(train, batch_size=xxx) # 将数据转换为iterator

	loss = nn.CrossEntropyLoss() # 定义损失函数为交叉熵损失函数
	updater = torch.optim.SGD(net.parameters(), lr=0.1) # 定义优化器为随机梯度下降算法（步长为0.1）

	import numpy as np
	import torch
	import random

	def same_seeds(seed):
	random.seed(seed)
	np.random.seed(seed)
	torch.manual_seed(seed)
	if torch.cuda.is_available():
	torch.cuda.manual_seed(seed)
	torch.cuda.manual_seed_all(seed)
	torch.backends.cudnn.benchmark = False
	torch.backends.cudnn.deterministic = True

	# 训练基本框架
	net.train()
	for epoch in range(num_epochs):
	for X, y in train_loader:
	optimizer.zero_grads() # 梯度清零
	pred = net(y)
	loss = criterion(pred, y) # 计算损失
	loss.backward() # 反向传播
	optimizer.step() # 优化

	model.eval()
	loss_record = []
	for x, y in valid_loader:
	x, y = x.to(device), y.to(device)
	with torch.no_grad():
	pred = model(x)
	loss = criterion(pred, y)
	loss_record.append(loss.detach().item())

	class My_Model(nn.Module):
	def __init__(self):
	super().__init__()
	# define some layers

	def forward(self, x):
	# do something
	return x

	# Method 1: define a function
	def my_loss(pred, target):
	loss = torch.mean((pred - target) ** 2) # MSE
	return loss

	# Method 2: define a nn.Module
	class MSELoss(nn.Module):
	def __init__(self):
	super().__init__()

	def forward(self, inputs, targets):
	loss = torch.mean((pred - target) ** 2)
	return loss

	class DiceLoss(nn.Module):
	def __init__(self,weight=None,size_average=True):
	super(DiceLoss,self).__init__()

	def forward(self,inputs,targets,smooth=1):
	inputs = F.sigmoid(inputs)
	inputs = inputs.view(-1)
	targets = targets.view(-1)
	intersection = (inputs * targets).sum()
	dice = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth)
	return 1 - dice