import numpy as np

import pandas as pd

import torch

from sklearn.preprocessing import LabelEncoder

from torch.utils.data import Dataset, DataLoader

import torch.nn.functional as F

import torch.nn as nn

from collections import Counter

torch.__version__


'1.4.0'

5.2 Pytorch处理结构化数据

简介

在介绍之前，我们首先要明确下什么是结构化的数据。结构化数据，可以从名称中看出，是高度组织和整齐格式化的数据。它是可以放入表格和电子表格中的数据类型。对我们来说，结构化数据可以理解为就是一张2维的表格，例如一个csv文件，就是结构化数据，在英文一般被称作Tabular Data或者叫 structured data，下面我们来看一下结构化数据的例子。

一下文件来自于fastai的自带数据集：
https://github.com/fastai/fastai/blob/master/examples/tabular.ipynb
fastai样例在这里

数据预处理

我们拿到的结构化数据，一般都是一个csv文件或者数据库中的一张表格，所以对于结构化的数据，我们直接使用pasdas库处理就可以了

#读入文件

df = pd.read_csv('./data/adult.csv')

#salary是这个数据集最后要分类的结果

df['salary'].unique()


array(['>=50k', '<50k'], dtype=object)


#查看数据类型

df.head()
age workclass fnlwgt education education-num marital-status occupation relationship race sex capital-gain capital-loss hours-per-week native-country salary
0 49 Private 101320 Assoc-acdm 12.0 Married-civ-spouse NaN Wife White Female 0 1902 40 United-States >=50k
1 44 Private 236746 Masters 14.0 Divorced Exec-managerial Not-in-family White Male 10520 0 45 United-States >=50k
2 38 Private 96185 HS-grad NaN Divorced NaN Unmarried Black Female 0 0 32 United-States <50k
3 38 Self-emp-inc 112847 Prof-school 15.0 Married-civ-spouse Prof-specialty Husband Asian-Pac-Islander Male 0 0 40 United-States >=50k
4 42 Self-emp-not-inc 82297 7th-8th NaN Married-civ-spouse Other-service Wife Black Female 0 0 50 United-States <50k 
#pandas的describe可以告诉我们整个数据集的大概结构，是非常有用的

df.describe()
age fnlwgt education-num capital-gain capital-loss hours-per-week
count 32561.000000 3.256100e+04 32074.000000 32561.000000 32561.000000 32561.000000
mean 38.581647 1.897784e+05 10.079815 1077.648844 87.303830 40.437456
std 13.640433 1.055500e+05 2.572999 7385.292085 402.960219 12.347429
min 17.000000 1.228500e+04 1.000000 0.000000 0.000000 1.000000
25% 28.000000 1.178270e+05 9.000000 0.000000 0.000000 40.000000
50% 37.000000 1.783560e+05 10.000000 0.000000 0.000000 40.000000
75% 48.000000 2.370510e+05 12.000000 0.000000 0.000000 45.000000
max 90.000000 1.484705e+06 16.000000 99999.000000 4356.000000 99.000000 
#查看一共有多少数据

len(df)


32561

对于模型的训练，只能够处理数字类型的数据，所以这里面我们首先要将数据分成三个类别

  • 训练的结果标签：即训练的结果，通过这个结果我们就能够明确的知道我们这次训练的任务是什么，是分类的任务，还是回归的任务。
  • 分类数据：这类的数据是离散的，无法通过直接输入到模型中进行训练，所以我们在预处理的时候需要优先对这部分进行处理，这也是数据预处理的主要工作之一
  • 数值型数据：这类数据是直接可以输入到模型中的，但是这部分数据有可能还是离散的，所以如果需要也可以对其进行处理，并且处理后会对训练的精度有很大的提升，这里暂且不讨论
#训练结果

result_var = 'salary'

#分类型数据

cat_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race','sex','native-country']

#数值型数据

cont_names = ['age', 'fnlwgt', 'education-num','capital-gain','capital-loss','hours-per-week']

人工确认完数据类型后，我们可以看一下分类类型数据的数量和分布情况

for col in df.columns:

    if col in cat_names:

        ccol=Counter(df[col])

        print(col,len(ccol),ccol)

        print("\r\n")


workclass 9 Counter({' Private': 22696, ' Self-emp-not-inc': 2541, ' Local-gov': 2093, ' ?': 1836, ' State-gov': 1298, ' Self-emp-inc': 1116, ' Federal-gov': 960, ' Without-pay': 14, ' Never-worked': 7})

​
education 16 Counter({’ HS-grad’: 10501, ’ Some-college’: 7291, ’ Bachelors’: 5355, ’ Masters’: 1723, ’ Assoc-voc’: 1382, ’ 11th’: 1175, ’ Assoc-acdm’: 1067, ’ 10th’: 933, ’ 7th-8th’: 646, ’ Prof-school’: 576, ’ 9th’: 514, ’ 12th’: 433, ’ Doctorate’: 413, ’ 5th-6th’: 333, ’ 1st-4th’: 168, ’ Preschool’: 51})

​
marital-status 7 Counter({’ Married-civ-spouse’: 14976, ’ Never-married’: 10683, ’ Divorced’: 4443, ’ Separated’: 1025, ’ Widowed’: 993, ’ Married-spouse-absent’: 418, ’ Married-AF-spouse’: 23})

​
occupation 16 Counter({’ Prof-specialty’: 4073, ’ Craft-repair’: 4028, ’ Exec-managerial’: 4009, ’ Adm-clerical’: 3720, ’ Sales’: 3590, ’ Other-service’: 3247, ’ Machine-op-inspct’: 1968, ’ ?’: 1820, ’ Transport-moving’: 1566, ’ Handlers-cleaners’: 1347, ’ Farming-fishing’: 977, ’ Tech-support’: 905, ’ Protective-serv’: 643, nan: 512, ’ Priv-house-serv’: 147, ’ Armed-Forces’: 9})

​
relationship 6 Counter({’ Husband’: 13193, ’ Not-in-family’: 8305, ’ Own-child’: 5068, ’ Unmarried’: 3446, ’ Wife’: 1568, ’ Other-relative’: 981})

​
race 5 Counter({’ White’: 27816, ’ Black’: 3124, ’ Asian-Pac-Islander’: 1039, ’ Amer-Indian-Eskimo’: 311, ’ Other’: 271})

​
sex 2 Counter({’ Male’: 21790, ’ Female’: 10771})

​
native-country 42 Counter({’ United-States’: 29170, ’ Mexico’: 643, ’ ?’: 583, ’ Philippines’: 198, ’ Germany’: 137, ’ Canada’: 121, ’ Puerto-Rico’: 114, ’ El-Salvador’: 106, ’ India’: 100, ’ Cuba’: 95, ’ England’: 90, ’ Jamaica’: 81, ’ South’: 80, ’ China’: 75, ’ Italy’: 73, ’ Dominican-Republic’: 70, ’ Vietnam’: 67, ’ Guatemala’: 64, ’ Japan’: 62, ’ Poland’: 60, ’ Columbia’: 59, ’ Taiwan’: 51, ’ Haiti’: 44, ’ Iran’: 43, ’ Portugal’: 37, ’ Nicaragua’: 34, ’ Peru’: 31, ’ Greece’: 29, ’ France’: 29, ’ Ecuador’: 28, ’ Ireland’: 24, ’ Hong’: 20, ’ Trinadad&Tobago’: 19, ’ Cambodia’: 19, ’ Thailand’: 18, ’ Laos’: 18, ’ Yugoslavia’: 16, ’ Outlying-US(Guam-USVI-etc)’: 14, ’ Hungary’: 13, ’ Honduras’: 13, ’ Scotland’: 12, ’ Holand-Netherlands’: 1})

​
​

下一步就是要将分类型数据转成数字型数据，在这部分里面，我们还做了对于缺失数据的填充

for col in df.columns:

    if col in cat_names:

        df[col].fillna('---')

        df[col] = LabelEncoder().fit_transform(df[col].astype(str))

    if col in cont_names:

        df[col]=df[col].fillna(0)

上面的代码中：

我们首先使用了pandas的fillna函数对分类的数据做了空值的填充，这里面标识成一个与其他现有值不一样的值就可以，这里面我使用的三个中划线 — 作为标记，然后就是使用了sklearn的LabelEncoder函数进行了数据的处理

然后有对我们的数值型的数据做了0填充的处理，对于数值型数据的填充，也可以使用平均值，或者其他方式填充，这个不是我们的重点，就不详细说明了。

df.head()
age workclass fnlwgt education education-num marital-status occupation relationship race sex capital-gain capital-loss hours-per-week native-country salary
0 49 4 101320 7 12.0 2 15 5 4 0 0 1902 40 39 >=50k
1 44 4 236746 12 14.0 0 4 1 4 1 10520 0 45 39 >=50k
2 38 4 96185 11 0.0 0 15 4 2 0 0 0 32 39 <50k
3 38 5 112847 14 15.0 2 10 0 1 1 0 0 40 39 >=50k
4 42 6 82297 5 0.0 2 8 5 2 0 0 0 50 39 <50k

数据处理完成后可以看到，现在所有的数据都是数字类型的了，可以直接输入到模型进行训练了.

#分割下训练数据和标签

Y = df['salary']

Y_label = LabelEncoder()

Y=Y_label.fit_transform(Y)

Y


array([1, 1, 0, ..., 1, 0, 0])


X=df.drop(columns=result_var)

X
age workclass fnlwgt education education-num marital-status occupation relationship race sex capital-gain capital-loss hours-per-week native-country
0 49 4 101320 7 12.0 2 15 5 4 0 0 1902 40 39
1 44 4 236746 12 14.0 0 4 1 4 1 10520 0 45 39
2 38 4 96185 11 0.0 0 15 4 2 0 0 0 32 39
3 38 5 112847 14 15.0 2 10 0 1 1 0 0 40 39
4 42 6 82297 5 0.0 2 8 5 2 0 0 0 50 39
... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
32556 36 4 297449 9 13.0 0 10 1 4 1 14084 0 40 39
32557 23 0 123983 9 13.0 4 0 3 3 1 0 0 40 39
32558 53 4 157069 7 12.0 2 7 0 4 1 0 0 40 39
32559 32 2 217296 11 9.0 2 14 5 4 0 4064 0 22 39
32560 26 4 182308 15 10.0 2 10 0 4 1 0 0 40 39

32561 rows × 14 columns

以上，基本的数据预处理已经完成了，上面展示的只是一些必要的处理，如果要提高训练准确率还有很多技巧，这里就不详细说明了。

定义数据集

要使用pytorch处理数据，肯定要使用Dataset进行数据集的定义，下面定义一个简单的数据集

class tabularDataset(Dataset):

    def __init__(self, X, Y):

        self.x = X.values

        self.y = Y

    def __len__(self):

        return len(self.y)

    def __getitem__(self, idx):

        return (self.x[idx], self.y[idx])


train_ds = tabularDataset(X, Y)

可以直接使用索引访问定义好的数据集中的数据

train_ds[0]


(array([4.9000e+01, 4.0000e+00, 1.0132e+05, 7.0000e+00, 1.2000e+01,

        2.0000e+00, 1.5000e+01, 5.0000e+00, 4.0000e+00, 0.0000e+00,

        0.0000e+00, 1.9020e+03, 4.0000e+01, 3.9000e+01]),

 1)

定义模型

数据已经准备完毕了，下一步就是要定义我们的模型了，这里使用了3层线性层的简单模型作为处理

class tabularModel(nn.Module):

    def __init__(self):

        super().__init__()

        self.lin1 = nn.Linear(14, 500)

        self.lin2 = nn.Linear(500, 100)

        self.lin3 = nn.Linear(100, 2)

        self.bn_in = nn.BatchNorm1d(14)

        self.bn1 = nn.BatchNorm1d(500)

        self.bn2 = nn.BatchNorm1d(100)

    def forward(self,x_in):

        #print(x_in.shape)

        x = self.bn_in(x_in)

        x = F.relu(self.lin1(x))

        x = self.bn1(x)

        #print(x)

        x = F.relu(self.lin2(x))

        x = self.bn2(x)

        #print(x)

        x = self.lin3(x)

        x=torch.sigmoid(x)

        return x

在定义模型的时候看到了我们加入了Batch Normalization来做批量的归一化：
批量归一化的内容请见这篇文章：https://mp.weixin.qq.com/s/FFLQBocTZGqnyN79JbSYcQ

或者扫描这个二维码，在微信中查看:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nmttIjq2-1618641614650)(https://raw.githubusercontent.com/zergtant/pytorch-handbook/master/deephub.jpg)]

训练

#训练前指定使用的设备

DEVICE=torch.device("cpu")

if torch.cuda.is_available():

        DEVICE=torch.device("cuda")

print(DEVICE)


cuda


#损失函数

criterion =nn.CrossEntropyLoss()


#实例化模型

model = tabularModel().to(DEVICE)

print(model)


tabularModel(

  (lin1): Linear(in_features=14, out_features=500, bias=True)

  (lin2): Linear(in_features=500, out_features=100, bias=True)

  (lin3): Linear(in_features=100, out_features=2, bias=True)

  (bn_in): BatchNorm1d(14, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

  (bn1): BatchNorm1d(500, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

  (bn2): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

)


#测试模型是否没问题

rn=torch.rand(3,14).to(DEVICE)

model(rn)


tensor([[0.5110, 0.1931],

        [0.4274, 0.5801],

        [0.5549, 0.7322]], device='cuda:0', grad_fn=<SigmoidBackward>)


#学习率

LEARNING_RATE=0.01

#BS

batch_size = 1024

#优化器

optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)


#DataLoader加载数据

train_dl = DataLoader(train_ds, batch_size=batch_size,shuffle=True)

以上的基本步骤是每个训练过程都需要的，所以就不多介绍了，下面开始进行模型的训练

%%time

model.train()

#训练10轮

TOTAL_EPOCHS=100

#记录损失函数

losses = [];

for epoch in range(TOTAL_EPOCHS):

    for i, (x, y) in enumerate(train_dl):

        x = x.float().to(DEVICE) #输入必须未float类型

        y = y.long().to(DEVICE) #结果标签必须未long类型

        #清零

        optimizer.zero_grad()

        outputs = model(x)

        #计算损失函数

        loss = criterion(outputs, y)

        loss.backward()

        optimizer.step()

        losses.append(loss.cpu().data.item())

    print ('Epoch : %d/%d,   Loss: %.4f'%(epoch+1, TOTAL_EPOCHS, np.mean(losses)))


Epoch : 1/100,   Loss: 0.4936

Epoch : 2/100,   Loss: 0.4766

Epoch : 3/100,   Loss: 0.4693

Epoch : 4/100,   Loss: 0.4653

Epoch : 5/100,   Loss: 0.4627

Epoch : 6/100,   Loss: 0.4606

Epoch : 7/100,   Loss: 0.4591

Epoch : 8/100,   Loss: 0.4582

Epoch : 9/100,   Loss: 0.4573

Epoch : 10/100,   Loss: 0.4565

Epoch : 11/100,   Loss: 0.4557

Epoch : 12/100,   Loss: 0.4551

Epoch : 13/100,   Loss: 0.4546

Epoch : 14/100,   Loss: 0.4540

Epoch : 15/100,   Loss: 0.4535

Epoch : 16/100,   Loss: 0.4530

Epoch : 17/100,   Loss: 0.4526

Epoch : 18/100,   Loss: 0.4522

Epoch : 19/100,   Loss: 0.4519

Epoch : 20/100,   Loss: 0.4515

Epoch : 21/100,   Loss: 0.4511

Epoch : 22/100,   Loss: 0.4508

Epoch : 23/100,   Loss: 0.4504

Epoch : 24/100,   Loss: 0.4502

Epoch : 25/100,   Loss: 0.4499

Epoch : 26/100,   Loss: 0.4496

Epoch : 27/100,   Loss: 0.4492

Epoch : 28/100,   Loss: 0.4489

Epoch : 29/100,   Loss: 0.4486

Epoch : 30/100,   Loss: 0.4483

Epoch : 31/100,   Loss: 0.4480

Epoch : 32/100,   Loss: 0.4477

Epoch : 33/100,   Loss: 0.4474

Epoch : 34/100,   Loss: 0.4471

Epoch : 35/100,   Loss: 0.4469

Epoch : 36/100,   Loss: 0.4466

Epoch : 37/100,   Loss: 0.4463

Epoch : 38/100,   Loss: 0.4460

Epoch : 39/100,   Loss: 0.4458

Epoch : 40/100,   Loss: 0.4455

Epoch : 41/100,   Loss: 0.4452

Epoch : 42/100,   Loss: 0.4449

Epoch : 43/100,   Loss: 0.4447

Epoch : 44/100,   Loss: 0.4445

Epoch : 45/100,   Loss: 0.4442

Epoch : 46/100,   Loss: 0.4439

Epoch : 47/100,   Loss: 0.4437

Epoch : 48/100,   Loss: 0.4434

Epoch : 49/100,   Loss: 0.4432

Epoch : 50/100,   Loss: 0.4429

Epoch : 51/100,   Loss: 0.4426

Epoch : 52/100,   Loss: 0.4424

Epoch : 53/100,   Loss: 0.4421

Epoch : 54/100,   Loss: 0.4419

Epoch : 55/100,   Loss: 0.4417

Epoch : 56/100,   Loss: 0.4414

Epoch : 57/100,   Loss: 0.4411

Epoch : 58/100,   Loss: 0.4409

Epoch : 59/100,   Loss: 0.4406

Epoch : 60/100,   Loss: 0.4404

Epoch : 61/100,   Loss: 0.4402

Epoch : 62/100,   Loss: 0.4399

Epoch : 63/100,   Loss: 0.4397

Epoch : 64/100,   Loss: 0.4394

Epoch : 65/100,   Loss: 0.4392

Epoch : 66/100,   Loss: 0.4390

Epoch : 67/100,   Loss: 0.4387

Epoch : 68/100,   Loss: 0.4384

Epoch : 69/100,   Loss: 0.4382

Epoch : 70/100,   Loss: 0.4380

Epoch : 71/100,   Loss: 0.4377

Epoch : 72/100,   Loss: 0.4375

Epoch : 73/100,   Loss: 0.4373

Epoch : 74/100,   Loss: 0.4371

Epoch : 75/100,   Loss: 0.4368

Epoch : 76/100,   Loss: 0.4366

Epoch : 77/100,   Loss: 0.4364

Epoch : 78/100,   Loss: 0.4362

Epoch : 79/100,   Loss: 0.4360

Epoch : 80/100,   Loss: 0.4358

Epoch : 81/100,   Loss: 0.4356

Epoch : 82/100,   Loss: 0.4353

Epoch : 83/100,   Loss: 0.4351

Epoch : 84/100,   Loss: 0.4348

Epoch : 85/100,   Loss: 0.4346

Epoch : 86/100,   Loss: 0.4344

Epoch : 87/100,   Loss: 0.4342

Epoch : 88/100,   Loss: 0.4340

Epoch : 89/100,   Loss: 0.4338

Epoch : 90/100,   Loss: 0.4336

Epoch : 91/100,   Loss: 0.4333

Epoch : 92/100,   Loss: 0.4331

Epoch : 93/100,   Loss: 0.4329

Epoch : 94/100,   Loss: 0.4328

Epoch : 95/100,   Loss: 0.4326

Epoch : 96/100,   Loss: 0.4324

Epoch : 97/100,   Loss: 0.4322

Epoch : 98/100,   Loss: 0.4320

Epoch : 99/100,   Loss: 0.4318

Epoch : 100/100,   Loss: 0.4316

Wall time: 49.6 s

训练完成后我们可以看一下模型的准确率

model.eval()

correct = 0

total = 0

for i,(x, y) in enumerate(train_dl):

    x = x.float().to(DEVICE)

    y = y.long()

    outputs = model(x).cpu()

    _, predicted = torch.max(outputs.data, 1)

    total += y.size(0)

    correct += (predicted == y).sum()

print('准确率: %.4f %%' % (100 * correct / total))


准确率: 89.0000 %

以上就是基本的流程了

[Pytorch框架] 5.2 Pytorch处理结构化数据的更多相关文章

  1. Spark如何与深度学习框架协作，处理非结构化数据

    随着大数据和AI业务的不断融合,大数据分析和处理过程中,通过深度学习技术对非结构化数据(如图片.音频.文本)进行大数据处理的业务场景越来越多.本文会介绍Spark如何与深度学习框架进行协同工作,在大数 ...

  2. Salesforce开源TransmogrifAI：用于结构化数据的端到端AutoML库

    AutoML 即通过自动化的机器学习实现人工智能模型的快速构建,它可以简化机器学习流程,方便更多人利用人工智能技术.近日,软件行业巨头 Salesforce 开源了其 AutoML 库 Transmo ...

  3. Bigtable：一个分布式的结构化数据存储系统

    Bigtable:一个分布式的结构化数据存储系统 摘要 Bigtable是一个管理结构化数据的分布式存储系统,它被设计用来处理海量数据:分布在数千台通用服务器上的PB级的数据.Google的很多项目将 ...

  4. Spark SQL - 对大规模的结构化数据进行批处理和流式处理

    Spark SQL - 对大规模的结构化数据进行批处理和流式处理 大体翻译自:https://jaceklaskowski.gitbooks.io/mastering-apache-spark/con ...

  5. MySQL 5.7：非结构化数据存储的新选择

    本文转载自:http://www.innomysql.net/article/23959.html (只作转载, 不代表本站和博主同意文中观点或证实文中信息) 工作10余年,没有一个版本能像MySQL ...

  6. WordPress插件--WP BaiDu Submit结构化数据插件又快又全的向百度提交网页

    一.WP BaiDu Submit 简介 WP BaiDu Submit帮助具有百度站长平台链接提交权限的用户自动提交最新文章,以保证新链接可以及时被百度收录. 安装WP BaiDu Submit后, ...

  7. 利用Gson和SharePreference存储结构化数据

    问题的导入 Android互联网产品通常会有很多的结构化数据需要保存,比如对于登录这个流程,通常会保存诸如username.profile_pic.access_token等等之类的数据,这些数据可以 ...

  8. 最近打算体验一下discuz，有不错的结构化数据插件

    提交sitemap是每位站长必做的事情,但是提交到哪里,能不能提交又是另外一回事.国内的话百度是大伙都会盯的蛋糕,BD站长工具也会去注册的,可有些账号sitemap模块一直不能用,或许是等级不够,就像 ...

  9. seo之google rich-snippets丰富网页摘要结构化数据（微数据）实例代码

    seo之google rich-snippets丰富网页摘要结构化数据(微数据)实例代码 网页摘要是搜索引擎搜索结果下的几行字,用户能通过网页摘要迅速了解到网页的大概内容,传统的摘要是纯文字摘要,而结 ...

  10. 【阿里云产品公测】结构化数据服务OTS之JavaSDK初体验

    [阿里云产品公测]结构化数据服务OTS之JavaSDK初体验 作者:阿里云用户蓝色之鹰 一.OTS简单介绍 OTS 是构建在阿里云飞天分布式系统之上的NoSQL数据库服务,提供海量结构化数据的存储和实 ...

随机推荐

  1. ggplot axis text 拐弯

    scale_y_discrete(position = "left",labels=function(x) str_wrap(x, width=48)) +

  2. kubeadm部署单master Kuberntes集群

    本文参考kubernetes docs 使用kubeadm创建single master的Kuberntes集群 虚机两台Centos75 Kubernetes Yum Repo采用国内阿里源 版本 ...

  3. Python之路径处理

    路径处理,需导入 os包 1 import os # 导入 os 包 2 3 """获取运行脚本文件夹的路径""" 4 current_di ...

  4. 在linux下创建KVM虚拟机

    Kernel-based Virtual Machine的简称,是一个开源的系统虚拟化模块,自Linux 2.6.20之后集成在Linux的各个主要发行版本中.它使用Linux自身的调度器进行管理,所 ...

  5. Hadoop警告信息：WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform.

    when键入命令: hadoop fs -ls / 若出现以下警告信息: Hadoop警告问题:WARN util.NativeCodeLoader: Unable to load native-ha ...

  6. IDEA设置自定义代码模板

    1. 进入IDEA界面,File–>Settings 注:其中, $END$代表打印字符串后光标所处的位置 如: System.out.println($END$); 表示输出后光标在()里面.

  7. element ui upload 组件多文件上传，最终只显示上传一个的问题

    问题描述:一次选多张图片上传的时候界面上只有一张图片显示,并且上传调用的接口次数与选择的图片数量一致,且接口已200. JSON格式,"url"是最终显示的图片地址 {     & ...

  8. 对于利用js实现表单的验证问题--其实菜鸟教程都有啦，但还是想要记录一下

    关于利用js实现表单的验证的实现 在jsp页面里面加上名为的标签,然后将以下代码跟奴自己的变量放进去: 记得要放在function的方法里面!!! 之后就需要在form标签里面加上onsubmit=& ...

  9. 干货来袭！3天0基础Python实战项目快速学会人工智能必学数学基础全套（含源码）（第3天）概率分析篇：条件概率、全概率与贝叶斯公式

    第1天:线性代数篇:矩阵.向量.实战编程 第2天:微积分篇:极限与导数.梯度下降.积分.实战编程 第3天:概率分析篇:条件概率与全概率.贝叶斯公式.实战项目 目录 前言 一.概率与机器学习 1.1 概 ...

  10. Jan Ozer：高清直播互动场景下的硬编码如何选型？

    前言 高清直播逐渐普及,硬编码也成为大势所趋.在 RTE 2022 大会上,来自 NETINT 的 Jan Ozer 通过一系列的对比测试结果,详细分享了如何为高清直播互动场景进行硬编码的技术选型. ...