用Paddle自动生成二次元人物头像

用Paddle自动生成二次元人物头像

想画出独一无二的动漫头像吗?不会画也没关系!只需要输入一些随机数让卷积神经网络为你画出精致并且独一无二的动漫头像!

同时本项目也是绝佳的学习DCGAN的例子,通过趣味解读深入浅出地了解GAN的魔法世界!

快开始制作你自己的二次元头像吧!!!

先来看看效果图

欢迎大家fork学习~有任何问题欢迎在评论区留言互相交流哦

这里一点小小的宣传,我感兴趣的领域包括迁移学习、生成对抗网络、。欢迎交流关注。来AI Studio互粉吧等你哦

1 项目简介

本项目基于paddlepaddle,结合生成对抗网络(DCGAN),通过弱监督学习的方式,训练生成二次元人物头像网络


1.1 DCGAN

1.1.1 背景介绍

DCGAN是深层卷积网络与 GAN 的结合,其基本原理与 GAN 相同,只是将生成网络和判别网络用两个卷积网络(CNN)替代。为了提高生成样本的质量和网络的收敛速度,论文中的 DCGAN 在网络结构上进行了一些改进:

  • 取消 pooling 层:在网络中,所有的pooling层使用步幅卷积(strided convolutions)(判别器)和微步幅度卷积(fractional-strided convolutions)(生成器)进行替换。
  • 加入 batch normalization:在生成器和判别器中均加入batchnorm。
  • 使用全卷积网络:去掉了FC层,以实现更深的网络结构。
  • 激活函数:在生成器(G)中,最后一层使用Tanh函数,其余层采用 ReLu 函数 ; 判别器(D)中都采用LeakyReLu。

DCGAN的生成器G结构如下图所示:


1.1.2 本项目由Chainer项目Chainerで顔イラストの自動生成改写为PaddlePaddle项目


1.2 本文的改进

  • 将Adam优化器beta1参数设置为0.8,具体请参考原论文
  • 将BatchNorm批归一化中momentum参数设置为0.5
  • 将判别器(D)激活函数由elu改为leaky_relu,并将alpha参数设置为0.2
  • 在判别器(D)中增加Dropout层,并将dropout_prob设置为0.4
  • 将生成器(G)中的第一层全连接层改为基本残差模块

损失函数选用softmax_with_cross_entropy,公式如下:

l o s s j = − logits l a b e l j + log ⁡ ( ∑ i = 0 K exp ⁡ ( logits i ) ) , j = 1 , . . . , K loss_j = -\text{logits}_{label_j} +\log\left(\sum_{i=0}^{K}\exp(\text{logits}_i)\right), j = 1,..., K lossj=logitslabelj+log(i=0Kexp(logitsi)),j=1,...,K


1.2.1 改进后,网络收敛速度明显加快,原项目训练时间需要300个epoch训练超过10h,改进后训练epoch仅需要90个epoch训练时间3个小时左右


安装缺失库scikit-image并解压数据集

pip install scikit-image 
unzip data/data17962/二次元人物头像.zip -d data/ 
mkdir ./work/Output 
mkdir ./work/Generate 

定义数据预处理工具-DataReader

import os 
import cv2 
import numpy as np 
import paddle.dataset as dataset 
from skimage import io,color,transform 
import matplotlib.pyplot as plt 
import math 
import time 
import paddle 
import paddle.fluid as fluid 
import six img_dim = 96 '''准备数据,定义Reader()''' 
PATH = 'data/faces/' 
TEST = 'data/faces/' 
class DataGenerater: 
def __init__(self): 
'''初始化''' 
self.datalist = os.listdir(PATH) 
self.testlist = os.listdir(TEST) def load(self, image): 
'''读取图片''' 
img = io.imread(image) 
img = transform.resize(img,(img_dim,img_dim)) 
img = img.transpose() 
img = img.astype('float32') 
return img def create_train_reader(self): 
'''给dataset定义reader''' def reader(): 
for img in self.datalist: 
#print(img) 
try: 
i = self.load(PATH + img) 
yield i.astype('float32') 
except Exception as e: 
print(e) 
return reader def create_test_reader(self,): 
'''给test定义reader''' 
def reader(): 
for img in self.datalist: 
#print(img) 
try: 
i = self.load(PATH + img) 
yield i.astype('float32') 
except Exception as e: 
print(e) 
return reader def train(batch_sizes = 32): 
reader = DataGenerater().create_train_reader() 
return reader def test(): 
reader = DataGenerater().create_test_reader() 
return reader 

测试DataReader并输出图片

train_reader = paddle.batch( 
paddle.reader.shuffle( 
reader=train(), buf_size=128*10 
), 
batch_size=128 
) 
for batch_id, data in enumerate(train_reader()): 
for i in range(10): 
image = data[i].transpose() 
plt.subplot(1, 10, i + 1) 
plt.imshow(image, vmin=-1, vmax=1) 
plt.axis('off') 
plt.xticks([]) 
plt.yticks([]) 
plt.subplots_adjust(wspace=0.1,hspace=0.1) 
plt.show() 
break 

在这里插入图片描述

定义网络功能模块

包括卷积池化组、BatchNorm层、全连接层、转置全连接层、卷积BN复合层

use_cudnn = True 
use_gpu = True 
n = 0 
def bn(x, name=None, act=None,momentum=0.5): 
return fluid.layers.batch_norm( 
x, 
param_attr=name + '1', 
# 指定权重参数属性的对象 
bias_attr=name + '2', 
# 指定偏置的属性的对象 
moving_mean_name=name + '3', 
# moving_mean的名称 
moving_variance_name=name + '4', 
# moving_variance的名称 
name=name, 
act=act, 
momentum=momentum, 
) ###卷积池化组 
def conv(x, num_filters,name=None, act=None): 
return fluid.nets.simple_img_conv_pool( 
input=x, 
filter_size=5, 
num_filters=num_filters, 
pool_size=2, 
# 池化窗口大小 
pool_stride=2, 
# 池化滑动步长 
param_attr=name + 'w', 
bias_attr=name + 'b', 
use_cudnn=use_cudnn, 
act=act 
) ###全连接层 
def fc(x, num_filters, name=None, act=None): 
return fluid.layers.fc( 
input=x, 
size=num_filters, 
act=act, 
param_attr=name + 'w', 
bias_attr=name + 'b' 
) ###转置卷积层 
def deconv(x, num_filters, name=None, filter_size=5, stride=2, dilation=1, padding=2, output_size=None, act=None): 
return fluid.layers.conv2d_transpose( 
input=x, 
param_attr=name + 'w', 
bias_attr=name + 'b', 
num_filters=num_filters, 
# 滤波器数量 
output_size=output_size, 
# 输出图片大小 
filter_size=filter_size, 
# 滤波器大小 
stride=stride, 
# 步长 
dilation=dilation, 
# 膨胀比例大小 
padding=padding, 
use_cudnn=use_cudnn, 
# 是否使用cudnn内核 
act=act 
# 激活函数 
) def conv_bn_layer(input, 
ch_out, 
filter_size, 
stride, 
padding, 
act=None, 
groups=64, 
name=None): 
tmp = fluid.layers.conv2d( 
input=input, 
filter_size=filter_size, 
num_filters=ch_out, 
stride=stride, 
padding=padding, 
act=None, 
bias_attr=name + '_conv_b', 
param_attr=name + '_conv_w', 
) 
return fluid.layers.batch_norm( 
input=tmp, 
act=act, 
param_attr=name + '_bn_1', 
# 指定权重参数属性的对象 
bias_attr=name + '_bn_2', 
# 指定偏置的属性的对象 
moving_mean_name=name + '_bn_3', 
# moving_mean的名称 
moving_variance_name=name + '_bn_4', 
# moving_variance的名称 
name=name + '_bn_', 
momentum=0.5, 
) 

定义基本残差模块

残差模块如图所示,本文采用的是基本模块连接方式,由两个输出通道数相同的3x3卷积组成。

def shortcut(input, ch_in, ch_out, stride,name): 
if ch_in != ch_out: 
return conv_bn_layer(input, ch_out, 1, stride, 0, None,name=name) 
else: 
return input def basicblock(input, ch_in, ch_out, stride,name,act): 
tmp = conv_bn_layer(input, ch_out, 3, stride, 1, name=name + '_1_',act=act) 
tmp = conv_bn_layer(tmp, ch_out, 3, 1, 1, act=None, name=name + '_2_') 
short = shortcut(input, ch_in, ch_out, stride,name=name) 
return fluid.layers.elementwise_add(x=tmp, y=short, act='relu') def layer_warp(block_func, input, ch_in, ch_out, count, stride,name,act='relu'): 
tmp = block_func(input, ch_in, ch_out, stride,name=name + '1',act=act) 
for i in range(1, count): 
tmp = block_func(tmp, ch_out, ch_out, 1,name=name + str(i + 1),act=act) 
return tmp 

判别器

  • 将BatchNorm批归一化中momentum参数设置为0.5
  • 将判别器(D)激活函数由elu改为leaky_relu,并将alpha参数设置为0.2
  • 在判别器(D)中增加Dropout层,并将dropout_prob设置为0.4

输入为大小96x96的RGB三通道图片

输出结果经过一层全连接层最后为shape为[batch_size,2]的Tensor

###判别器 
def D(x): 
# (96 + 2 * 1 - 4) / 2 + 1 = 48 
x = conv_bn_layer(x, 64, 4, 2, 1, act=None, name='conv_bn_1') 
x = fluid.layers.leaky_relu(x,alpha=0.2,name='leaky_relu_1') 
x = fluid.layers.dropout(x,0.4,name='dropout1') 
# (48 + 2 * 1 - 4) / 2 + 1 = 24 
x = conv_bn_layer(x, 128, 4, 2, 1, act=None, name='conv_bn_2') 
x = fluid.layers.leaky_relu(x,alpha=0.2,name='leaky_relu_2') 
x = fluid.layers.dropout(x,0.4,name='dropout2') 
# (24 + 2 * 1 - 4) / 2 + 1 = 12 
x = conv_bn_layer(x, 256, 4, 2, 1, act=None, name='conv_bn_3') 
x = fluid.layers.leaky_relu(x,alpha=0.2,name='leaky_relu_3') 
x = fluid.layers.dropout(x,0.4,name='dropout3') 
# (12 + 2 * 1 - 4) / 2 + 1 = 6 
x = conv_bn_layer(x, 512, 4, 2, 1, act=None, name='conv_bn_4') 
x = fluid.layers.leaky_relu(x,alpha=0.2,name='leaky_relu_4') 
x = fluid.layers.dropout(x,0.4,name='dropout4') 
x = fluid.layers.reshape(x,shape=[-1, 512 * 6 * 6]) 
x = fc(x, 2, name='fc1') 
return x 

生成器

  • 将BatchNorm批归一化中momentum参数设置为0.5
  • 将生成器(G)中的第一层全连接层改为基本残差模块

输入Tensor的Shape为[batch_size,72]其中每个数值大小为0~1之间的float32随机数

输出为大小96x96RGB三通道图片

###生成器 
def G(x): 
#x = fc(x,6 * 6 * 2,name='g_fc1',act='relu') 
#x = bn(x, name='g_bn_1', act='relu',momentum=0.5) 
x = fluid.layers.reshape(x, shape=[-1, 2, 6, 6]) 
x = layer_warp(basicblock, x, 2, 256, 1, 1, name='g_res1', act='relu') # 2 * (6 - 1) - 2 * 1 + 4 = 12 
x = deconv(x, num_filters=256, filter_size=4, stride=2, padding=1, name='g_deconv_1') 
x = bn(x, name='g_bn_2', act='relu',momentum=0.5) # 2 * (12 - 1) - 2 * 1 + 4 = 24 
x = deconv(x, num_filters=128, filter_size=4, stride=2, padding=1, name='g_deconv_2') 
x = bn(x, name='g_bn_3', act='relu',momentum=0.5) # 2 * (24 - 1) - 2 * 1 + 4 = 48 
x = deconv(x, num_filters=64, filter_size=4, stride=2, padding=1, name='g_deconv_3') 
x = bn(x, name='g_bn_4', act='relu',momentum=0.5) # 2 * (48 - 1) - 2 * 1 + 4 = 96 
x = deconv(x, num_filters=3, filter_size=4, stride=2, padding=1, name='g_deconv_4',act='relu') return x 

损失函数选用softmax_with_cross_entropy,公式如下:

l o s s j = − logits l a b e l j + log ⁡ ( ∑ i = 0 K exp ⁡ ( logits i ) ) , j = 1 , . . . , K loss_j = -\text{logits}_{label_j} +\log\left(\sum_{i=0}^{K}\exp(\text{logits}_i)\right), j = 1,..., K lossj=logitslabelj+log(i=0Kexp(logitsi)),j=1,...,K

###损失函数 
def loss(x, label): 
return fluid.layers.mean(fluid.layers.softmax_with_cross_entropy(logits=x, label=label)) 

训练网络

设置的超参数为:

  • 学习率:2e-4
  • Epoch: 300
  • Mini-Batch:100
  • 输入Tensor长度:72
import IPython.display as display 
import warnings 
warnings.filterwarnings('ignore') img_dim = 96 
LEARENING_RATE = 2e-4 
SHOWNUM = 12 
epoch = 300 
output = "work/Output/" 
batch_size = 100 
G_DIMENSION = 72 
d_program = fluid.Program() 
dg_program = fluid.Program() ###定义判别器program 
# program_guard()接口配合with语句将with block中的算子和变量添加指定的全局主程序(main_program)和启动程序(start_progrom) 
with fluid.program_guard(d_program): 
# 输入图片大小为28*28 
img = fluid.layers.data(name='img', shape=[None,3,img_dim,img_dim], dtype='float32') 
# 标签shape=1 
label = fluid.layers.data(name='label', shape=[None,1], dtype='int64') 
d_logit = D(img) 
d_loss = loss(x=d_logit, label=label) ###定义生成器program 
with fluid.program_guard(dg_program): 
noise = fluid.layers.data(name='noise', shape=[None,G_DIMENSION], dtype='float32') 
#label = np.ones(shape=[batch_size, G_DIMENSION], dtype='int64') 
# 噪声数据作为输入得到生成照片 
g_img = G(x=noise) 
g_program = dg_program.clone() 
g_program_test = dg_program.clone(for_test=True) # 判断生成图片为真实样本的概率 
dg_logit = D(g_img) # 计算生成图片被判别为真实样本的loss 
dg_loss = loss( 
x=dg_logit, 
label=fluid.layers.fill_constant_batch_size_like(input=noise, dtype='int64', shape=[-1,1], value=1) 
) ###优化函数 
opt = fluid.optimizer.Adam(learning_rate=LEARENING_RATE,beta1=0.5) 
opt.minimize(loss=d_loss) 
parameters = [p.name for p in g_program.global_block().all_parameters()] 
opt.minimize(loss=dg_loss, parameter_list=parameters) train_reader = paddle.batch( 
paddle.reader.shuffle( 
reader=train(), buf_size=50000 
), 
batch_size=batch_size 
) 
test_reader = paddle.batch( 
paddle.reader.shuffle( 
reader=test(), buf_size=10000 
), 
batch_size=10 
) 
###执行器 
if use_gpu: 
exe = fluid.Executor(fluid.CUDAPlace(0)) 
else: 
exe = fluid.Executor(fluid.CPUPlace()) 
start_program = fluid.default_startup_program() 
exe.run(start_program) 
#加载模型 
#fluid.io.load_persistables(exe,'work/Model/D/',d_program) 
#fluid.io.load_persistables(exe,'work/Model/G/',dg_program) ###训练过程 
t_time = 0 
losses = [[], []] 
# 判别器迭代次数 
NUM_TRAIN_TIME_OF_DG = 2 
# 最终生成的噪声数据 
const_n = np.random.uniform( 
low=0.0, high=1.0, 
size=[batch_size, G_DIMENSION]).astype('float32') 
test_const_n = np.random.uniform( 
low=0.0, high=1.0, 
size=[100, G_DIMENSION]).astype('float32') #plt.ion() 
now = 0 
for pass_id in range(epoch): 
fluid.io.save_persistables(exe, 'work/Model/G', dg_program) 
fluid.io.save_persistables(exe, 'work/Model/D', d_program) 
for batch_id, data in enumerate(train_reader()): # enumerate()函数将一个可遍历的数据对象组合成一个序列列表 
if len(data) != batch_size: 
continue # 生成训练过程的噪声数据 
noise_data = np.random.uniform( 
low=0.0, high=1.0, 
size=[batch_size, G_DIMENSION]).astype('float32') 
# 真实图片 
real_image = np.array(data) 
# 真实标签 
real_labels = np.ones(shape=[batch_size,1], dtype='int64') 
# real_labels = real_labels * 10 
# 虚假标签 
fake_labels = np.zeros(shape=[batch_size,1], dtype='int64') 
s_time = time.time() 
#print(np.max(noise_data)) 
# 虚假图片 
generated_image = exe.run(g_program, 
feed={'noise': noise_data}, 
fetch_list=[g_img])[0] ###训练判别器 
# D函数判断虚假图片为假的loss 
d_loss_1 = exe.run(d_program, 
feed={ 
'img': generated_image, 
'label': fake_labels, 
}, 
fetch_list=[d_loss])[0][0] 
# D函数判断真实图片为真的loss 
d_loss_2 = exe.run(d_program, 
feed={ 
'img': real_image, 
'label': real_labels, 
}, 
fetch_list=[d_loss])[0][0] d_loss_n = d_loss_1 + d_loss_2 
losses[0].append(d_loss_n) ###训练生成器 
for _ in six.moves.xrange(NUM_TRAIN_TIME_OF_DG): 
noise_data = np.random.uniform( # uniform()方法从一个均匀分布[low,high)中随机采样 
low=0.0, high=1.0, 
size=[batch_size, G_DIMENSION]).astype('float32') 
dg_loss_n = exe.run(dg_program, 
feed={'noise': noise_data}, 
fetch_list=[dg_loss])[0][0] 
losses[1].append(dg_loss_n) 
t_time += (time.time() - s_time) if batch_id % 500 == 0: 
if not os.path.exists(output): 
os.makedirs(output) 
# 每轮的生成结果 
generated_image = exe.run(g_program_test, feed={'noise': test_const_n}, fetch_list=[g_img])[0] 
#print(generated_image[1]) 
imgs = [] 
plt.figure(figsize=(15,15)) 
try: 
# for test in test_reader(): 
# for i in range(10): 
# image = test[i].transpose() 
# plt.subplot(4, 10, i + 1) 
# plt.imshow(image) 
# plt.axis('off') 
# plt.xticks([]) 
# plt.yticks([]) 
# plt.subplots_adjust(wspace=0.1, hspace=0.1) 
# break 
for i in range(100): 
image = generated_image[i].transpose() 
plt.subplot(10, 10, i + 1) 
plt.imshow(image) 
plt.axis('off') 
plt.xticks([]) 
plt.yticks([]) 
plt.subplots_adjust(wspace=0.1, hspace=0.1) 
# plt.subplots_adjust(wspace=0.1,hspace=0.1) 
msg = 'Epoch ID={0} Batch ID={1} \n D-Loss={2} G-Loss={3}'.format(pass_id + 92, batch_id, d_loss_n, dg_loss_n) 
#print(msg) 
plt.suptitle(msg,fontsize=20) 
plt.draw() 
#if batch_id % 10000 == 0: 
plt.savefig('{}/{:04d}_{:04d}.png'.format(output, pass_id + 92, batch_id),bbox_inches='tight') 
plt.pause(0.01) 
display.clear_output(wait=True) #plt.pause(0.01) 
except IOError: 
print(IOError) #plt.ioff() 
plt.close() 
plt.figure(figsize=(15, 6)) 
x = np.arange(len(losses[0])) 
plt.title('Loss') 
plt.xlabel('Number of Batch') 
plt.plot(x,np.array(losses[0]),'r-',label='D Loss') 
plt.plot(x,np.array(losses[1]),'b-',label='G Loss') 
plt.legend() 
plt.savefig('work/Train Process') 
plt.show() 

最后的损失变化曲线为

横向对比

每次生成一组shape为[1,72]的随机数,平均更改其中某个数值,依次生成20组随机数,输入生成器,得到横向对比图片,得到GAN神奇的过渡

改变发色深浅

改变头发颜色

import warnings 
warnings.filterwarnings('ignore') 
import IPython.display as display '''定义超参数''' 
img_dim = 96 
output = "Output/" 
G_DIMENSION = 72 
use_gpu = False 
dg_program = fluid.Program() ###定义生成器program 
with fluid.program_guard(dg_program): 
noise = fluid.layers.data(name='noise', shape=[None,G_DIMENSION], dtype='float32') 
#label = np.ones(shape=[batch_size, G_DIMENSION], dtype='int64') 
# 噪声数据作为输入得到生成照片 
g_img = G(x=noise) 
g_program = dg_program.clone() 
g_program_test = dg_program.clone(for_test=True) # 判断生成图片为真实样本的概率 
dg_logit = D(g_img) # 计算生成图片被判别为真实样本的loss 
dg_loss = loss( 
x=dg_logit, 
label=fluid.layers.fill_constant_batch_size_like(input=noise, dtype='int64', shape=[-1,1], value=1) 
) if use_gpu: 
exe = fluid.Executor(fluid.CUDAPlace(0)) 
else: 
exe = fluid.Executor(fluid.CPUPlace()) 
start_program = fluid.default_startup_program() 
exe.run(start_program) 
fluid.io.load_persistables(exe,'work/Model/G/',dg_program) 
plt.figure(figsize=(25,6)) 
try: 
for i in range(G_DIMENSION): 
noise = np.random.uniform(low=0.0, high=1.0,size=[G_DIMENSION]).astype('float32') 
const_n = [] 
for m in range(20): 
noise2 = noise.copy() 
noise2[i] = (m + 1) / 20 
const_n.append(noise2) 
const_n = np.array(const_n).astype('float32') 
#print(const_n) 
generated_image = exe.run(g_program, feed={'noise': const_n}, fetch_list=[g_img])[0] 
for j in range(20): 
image = generated_image[j].transpose() 
plt.subplot(1, 20, j + 1) 
plt.imshow(image) 
plt.axis('off') 
plt.xticks([]) 
plt.yticks([]) 
plt.subplots_adjust(wspace=0.1, hspace=0.1) 
#plt.suptitle('Generated Image') 
plt.savefig('work/Generate/generated_' + str(i + 1), bbox_inches='tight') 
display.clear_output(wait=True) 
#plt.show() 
except IOError: 
print(IOError) 

项目总结

简单介绍了一下DCGAN的原理,通过对原项目的改进和优化,一步一步依次对生成器和判别器以及训练过程进行介绍。
通过横向对比某个输入元素对生成图片的影响。平均更改其中某个数值,依次生成20组随机数,输入生成器,得到横向对比图片,得到GAN神奇的过渡。
DCGAN生成二次元头像仔细看是足以以假乱真的,通过DCGAN了解到GAN强大的“魔力”

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

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【TA】Unity角色二次元风格渲染

NRMToonLitSample Author : 文若 我的Demo地址 : NRMToonLitSample 学习视频地址 : Kerry大佬的 技术美术实战培训课程——卡通人物渲染方案 文章目录 NRMToonLitSample1. 模型贴图基本信息2. 基础渲染效果2.1 基础shader Toon2.2 光照模型效果第一步&am…

Fiora一款二次元的Web多人在线网络聊天系统

源码介绍 Fiora是一款偏二次元的Web多人在线聊天应用,使用Node.js、Mongodb、Socket.io和React编写,使用起来还行,挺简洁的,这里水个搭建教程,有兴趣的可以玩玩。 源码功能 好友,群组,私聊&a…

Unity制作二次元卡通渲染角色材质——1、资源分析

Unity制作二次元材质角色 回到目录 大家好,我是阿赵。 开始制作二次元角色材质之前,我觉得应该是先分析一下,我手上拿到的这个角色模型资源,总共有哪些信息是我们能用的。 所以这篇文章我不会分享具体的Shader,但我感觉…

WPF 3D 贴图: 为你的二次元老婆们做个3D画廊

文章目录 WPF3D系列为你的二次元老婆们做个3D画廊 WPF3D系列 💎WPF 3D初步|源码 新建一个立方体并调整视角相机控制:位置和视角的调节 💎键盘控制|源码💎鼠标控制|源码 💎为你的二次元老婆们做个3D画廊|源码&#x1f…

关于人工智能写作的发展以及看法

人工智能技术的快速发展使其应用领域得以扩展。从金融服务到小说创作,人工智能技术都占有了一席之地。 人工智能可以取代编辑吗?近日某公司开发了一个神码AI人工智能写作软件,据说现在人工智能可以理解超过85%的内容。现在也可以…

换一种姿势阅读《人工智能简史》

2017 年 12 月,一本名为《人工智能简史》的图书发布。这个时间节点对于多数普通人的生活来说不算特别,但正是从前一年开始,人工智能在世界范围内开始进入了一段新的飞速发展期。2017 年和 2018 年也是中国 AI 企业的创业热潮期。 你说这个时代…

【转载】人工智能发展简史

网络查阅资料时候,看到的对人工智能发展简史,较为完整的讲述,故转载,仅供学习使用,原文链接:https://www.aminer.cn/ai-history。侵删。 人工智能到底是什么?通常来说,人工智能&…

人工智能再次超越人类,这次是阅读理解

在斯坦福大学举办的阅读理解比赛中,由微软和阿里巴巴分别独立开发的人工智能的得分都超过了人类。 在斯坦福大学举办的阅读理解比赛中,由微软和阿里巴巴分别独立开发的人工智能(AI)模型的得分均超过了人类。 这一人工智能里程碑是…

与AI合作穿越剧 编剧徐婷:AI脑洞大,但无法替代人类的情感表达

热门喜剧秀《周六夜现场》本季提前结束,美剧《亿万》最新第七季的更新搁浅,漫威新电影《新刀锋战士》暂停拍摄……美国影视娱乐行业的编剧们以抵制AI为由的大罢工,开始影响诸多作品的产出,据说造成了100亿美元的损失。 这场罢工已…

人工智能简史+电子版原文

自从学习了人工智能,对其的发展史产生了浓厚的兴趣,于是选择了《人工智能简史》这本书细细品味。下面将分享我看书时的一些体会。 人工智能的发展过程 我们想要理解人工智能,首先要知道这个名词从何而来。1956年达特茅斯会议被公认为人工智能…

AI:周志华老师文章《关于强人工智能》的阅读笔记以及感悟

AI:周志华老师文章《关于强人工智能》的阅读笔记以及感悟 导读 关于人工智能,长期存在两种不同的目标或者理念。一种是希望借鉴人类的智能行为,研制出更好的工具以减轻人类智力劳动,一般称为“弱人工智能”,类似…

《人工智能》之《绪论》习题解析

教材:《人工智能及其应用》,蔡自兴等,2016m清华大学出版社(第5版) 参考书: 对应同系列博客:《人工智能》之《绪论》 《人工智能》之《绪论》习题解析 1 什么是人工智能?试从学科…

解读人工智能续写名著的经典论

这段时间,人工智能“续写”名著的现象受到舆论聚焦。在人工智能的“作品”中,“林黛玉大战孙悟空”之类“脑洞大开”的情节纷纷亮相,大大超出了一般人的预料。面对《聊斋志异》里的经典故事,人工智能竟然创作出了 “蒲松龄笔下的狼…

论人工智能——写在当今人工智能突飞猛进的时代

人工智能是现代科技领域最为热门的研究方向之一,它是一种基于计算机技术和算法的智能体系,可以模拟人类的思维和判断能力,实现诸如语音识别、图像识别、自然语言处理等多项智能化任务。在日常生活中,人工智能的应用已经变得日益广…

股票交易接口软件服务涵盖范围有哪些?

通常所说的股票交易接口软件是指量化交易程序员们可以自行查询各大交易网站或交易所的股票历史数据及行情数据的工具,如:实时报价;走势图;价差图;基金、债券、期货、外汇、保险等各类金融数据查询等,进行数…

android官方转圈圈,android 弹出之后,一直转圈圈??

flutter version: version: 1.0.01 environment: sdk: ">2.1.0 <3.0.0" photo: 0.4.5 1 code: GestureDetector( child: Text(从相册选择), onTap: () async { var assetPathList await PhotoManager.getImageAsset(); _pickAsset(PickType.onlyImage, pathL…

爬取股票的历史数据(个股)

股票的历史数据爬取 爬取网易财经的个股历史数据 爬取链接&#xff1a;http://quotes.money.163.com/trade/lsjysj_000001.html? 先爬取股票的对应的代码 爬取股票代码的网站 https://www.banban.cn/gupiao/list_sh.html 代码 import requests,pymysql,re,datetime impo…

计算机技能高考600分,高三一模成绩530高考能上600分吗

有可能。很多地方在高三为了督促同学复习不松懈&#xff0c;一模二模的考试往往试题难度会比高考更高&#xff01;同时模拟考也往往不像高考评分那么工整、有详尽的步骤分&#xff0c;这就导致了学生考分的偏低。三模的试卷由于接近高考了&#xff0c;学生的状态好了&#xff0…