2. 程式人生 > >機器學習-->深度學習-->pytorch學習

機器學習-->深度學習-->pytorch學習

阿新 • • 發佈：2019-01-11

本篇博文將大概的總結下深度學習框架pytorch的使用，其內容來自我在pytorch官方教程還有網上一些相關資料的總結，加上了一些自己的見解。

張量的說明

標量（Scalar）是隻有大小，沒有方向的量，如1，2，3等

向量（Vector）是有大小和方向的量，其實就是一串數字，如(1,2)

矩陣（Matrix）是好幾個向量拍成一排合併而成的一堆數字，如[1,2;3,4]

這裡寫圖片描述

標量，向量，矩陣它們三個也是張量，標量是零維的張量，向量是一維的張量，矩陣是二維的張量。

這裡寫圖片描述

除此之外，張量還可以是四維的、五維等等。

程式碼示例：

import torch
x=torch.Tensor(2
 
,3)##二維的張量
print x

1.0860e+32  4.5848e-41  7.0424e-38
0.0000e+00  4.4842e-44  0.0000e+00
[torch.FloatTensor of size 2x3]
import torch
x=torch.Tensor(4,2,3)##三維張量
print x

(0 ,.,.) = 
 -7.7057e-06  4.5772e-41 -7.7057e-06
  4.5772e-41  0.0000e+00  0.0000e+00

(1 ,.,.) = 
  0.0000e+00  0.0000e+00  0.0000e+00
  0.0000e+00  8.1459e-38  0.0000e+00

(2 ,.,.) = 
         nan  0.0000e+00
 
  7.7143e-28
  2.5353e+30  1.8460e+31  1.7466e+19

(3 ,.,.) = 
  1.8430e-37  0.0000e+00         nan
         nan  6.0185e-36  2.4062e-38
[torch.FloatTensor of size 4x2x3]

4x2x3的張量y由4個2x3的矩陣構成。

torch.tensor與numpy.array的轉換

import torch
import numpy as np

np_data = np.arange(6).reshape((2, 3))
torch_data = torch.from_numpy(np_data)##將numpy.array轉成torch.tensor
tensor2array = torch_data.numpy()##　將torch.tensort轉成numpy.array

print
 
 torch_data
print tensor2array,type(tensor2array)

 0  1  2
 3  4  5
[torch.LongTensor of size 2x3]

[[0 1 2]
[3 4 5]] 
<type 'numpy.ndarray'>

pytorch中的一些數學運算

# abs 絕對值計算
data = [-1, -2, 1, 2]
tensor = torch.FloatTensor(data)  # 轉換成32位浮點 tensor
print(
    '\nabs',
    '\nnumpy: ', np.abs(data),          # [1 2 1 2]
    '\ntorch: ', torch.abs(tensor)      # [1 2 1 2]
)

# sin   三角函式 sin
print(
    '\nsin',
    '\nnumpy: ', np.sin(data),      # [-0.84147098 -0.90929743  0.84147098  0.90929743]
    '\ntorch: ', torch.sin(tensor)  # [-0.8415 -0.9093  0.8415  0.9093]
)

# mean  均值
print(
    '\nmean',
    '\nnumpy: ', np.mean(data),         # 0.0
    '\ntorch: ', torch.mean(tensor)     # 0.0
)

矩陣運算：

# matrix multiplication 矩陣點乘
data = [[1,2], [3,4]]
tensor = torch.FloatTensor(data)  # 轉換成32位浮點 tensor
# correct method
print(
    '\nmatrix multiplication (matmul)',
    '\nnumpy: ', np.matmul(data, data),     # [[7, 10], [15, 22]]
    '\ntorch: ', torch.mm(tensor, tensor)   # [[7, 10], [15, 22]]
)

# !!!!  下面是錯誤的方法 !!!!
data = np.array(data)
print(
    '\nmatrix multiplication (dot)',
    '\nnumpy: ', data.dot(data),        # [[7, 10], [15, 22]] 在numpy 中可行
    '\ntorch: ', tensor.dot(tensor)     # torch 會轉換成 [1,2,3,4].dot([1,2,3,4) = 30.0
)

矩陣加法：

import torch
import numpy as np

a=torch.rand(5,3)
b=torch.rand(5,3)

print "a",a
print "b",b

print "a+b",a+b
print "torch.add(a,b)",torch.add(a,b)

res=torch.Tensor(5,3)

print "torch.add(a,b,out=res)",torch.add(a,b,out=res)##把運算結果儲存到res上

print "b.add_(a)",b.add_(a)##結果覆蓋b

a 
 0.0540  0.2670  0.6704
 0.7695  0.9178  0.8770
 0.6552  0.4423  0.1735
 0.1376  0.1208  0.6674
 0.7257  0.1426  0.1134
[torch.FloatTensor of size 5x3]

b 
 0.4811  0.7744  0.7762
 0.5247  0.6045  0.6148
 0.8366  0.8996  0.5378
 0.5236  0.4987  0.9592
 0.8462  0.8286  0.5010
[torch.FloatTensor of size 5x3]

a+b 
 0.5350  1.0413  1.4466
 1.2942  1.5223  1.4918
 1.4918  1.3419  0.7113
 0.6612  0.6195  1.6266
 1.5719  0.9712  0.6144
[torch.FloatTensor of size 5x3]

torch.add(a,b) 
 0.5350  1.0413  1.4466
 1.2942  1.5223  1.4918
 1.4918  1.3419  0.7113
 0.6612  0.6195  1.6266
 1.5719  0.9712  0.6144
[torch.FloatTensor of size 5x3]

torch.add(a,b,out=res) 
 0.5350  1.0413  1.4466
 1.2942  1.5223  1.4918
 1.4918  1.3419  0.7113
 0.6612  0.6195  1.6266
 1.5719  0.9712  0.6144
[torch.FloatTensor of size 5x3]

b.add_(a) 
 0.5350  1.0413  1.4466
 1.2942  1.5223  1.4918
 1.4918  1.3419  0.7113
 0.6612  0.6195  1.6266
 1.5719  0.9712  0.6144
[torch.FloatTensor of size 5x3]

Tensor的部分擷取和numpy裡面的切片很類似，操作幾乎一樣。

autograd自動微分

Variable：

我們把每個張量Tensor理解為雞蛋，那麼Variable就是存放這些雞蛋(torch.Tensor)的籃子。

import torch
from torch.autograd import Variable # torch 中 Variable 模組

# 先生雞蛋
tensor = torch.FloatTensor([[1,2],[3,4]])
# 把雞蛋放到籃子裡, requires_grad是參不參與誤差反向傳播, 要不要計算梯度
variable = Variable(tensor, requires_grad=True)

print(tensor)
"""
 1  2
 3  4
[torch.FloatTensor of size 2x2]
"""

print(variable)
"""
Variable containing:
 1  2
 3  4
[torch.FloatTensor of size 2x2]

Variable 計算, 梯度

Variable用來包裹tensor， 用Variable代替包住的tensor來進行一系列的運算 , 它在背景幕布後面一步步默默地搭建著一個龐大的系統, 叫做計算圖, computational graph. 這個圖是用來幹嘛的? 原來是將所有的計算步驟 (節點) 都連線起來, 最後進行誤差反向傳遞的時候, 一次性將所有 variable 裡面的修改幅度 (梯度) 都計算出來。

import torch
import numpy as np
from torch.autograd import Variable

x=Variable(torch.ones(2),requires_grad=True)##用Variable包住一個(2*1)的tensor,並且設定requires_grad=True參與誤差反向傳播, 要計算梯度

z=4*x*x
y=z.norm()

print "y:",y

y.backward()## 反向計算
print "x.grad:",x.grad##計算ｙ對ｘ的梯度

列印輸出
y: Variable containing:
 5.6569
[torch.FloatTensor of size 1]

x.grad: Variable containing:
 5.6569
 5.6569
[torch.FloatTensor of size 2]

需要注意：autograd是專門為了BP演算法設計的，所以這autograd只對輸出值為標量的有用，因為損失函式的輸出是一個標量。如果y是一個向量，那麼backward()函式就會失效。

autograd的內部機理：

之所以可以實現autograd多虧了Variable和Function這兩種資料型別的功勞。要進行autograd必需先將tensor資料包成Variable。Varibale和tensor基本一致，所區別在於多了下面幾個屬性。

這裡寫圖片描述

其中data屬性返回Variable裡面包裹的原始tensor值，就可以將一個Variable型別轉換成tensor型別；grad屬性返回其梯度值。

variable和function它們是彼此不分開的：

這裡寫圖片描述

如圖，假設我們有一個輸入變數input（資料型別為Variable）input是使用者輸入的，所以其創造者creator為null值，input經過第一個資料操作operation1（比如加減乘除運算）得到output1變數（資料型別仍為Variable），這個過程中會自動生成一個function1的變數（資料型別為Function的一個例項），而output1的創造者就是這個function1。隨後，output1再經過一個數據操作生成output2，這個過程也會生成另外一個例項function2，output2的創造者creator為function2。

在這個向前傳播的過程中，function1和function2記錄了資料input的所有操作歷史，當output2執行其backward函式時，會使得function2和function1自動反向計算input的導數值並存儲在grad屬性中。

creator為null的變數才能被返回導數，比如input，若把整個操作流看成是一張圖（Graph）,那麼像input這種creator為null的被稱之為圖的葉子（graph leaf）。而creator非null的變數比如output1和output2，是不能被返回導數的，它們的grad均為0。所以只有葉子節點才能被autograd。

獲取 Variable 裡面的資料

print(variable)     #  Variable 形式
"""
Variable containing:
 1  2
 3  4
[torch.FloatTensor of size 2x2]
"""

print(variable.data)    # tensor 形式
"""
 1  2
 3  4
[torch.FloatTensor of size 2x2]
"""

print(variable.data.numpy())    # numpy 形式
"""
[[ 1.  2.]
 [ 3.  4.]]

激勵函式

import torch
import torch.nn.functional as F     # 激勵函式都在這
from torch.autograd import Variable

# 做一些假資料來觀看影象
x = torch.linspace(-5, 5, 200)  # x data (tensor), shape=(100, 1)
x = Variable(x)



x_np = x.data.numpy()   # 換成 numpy array, 出圖時用

# 幾種常用的 激勵函式
y_relu = F.relu(x).data.numpy()
y_sigmoid = F.sigmoid(x).data.numpy()
y_tanh = F.tanh(x).data.numpy()
y_softplus = F.softplus(x).data.numpy()
# y_softmax = F.softmax(x)  softmax 比較特殊, 不能直接顯示, 不過他是關於概率的, 用於分類

批訓練

DataLoader 是 torch 給你用來包裝你的資料的工具. 將 (numpy array 或其他) 資料形式裝換成 Tensor, 然後再放進這個包裝器中。使用 DataLoader 有什麼好處呢? 就是他們幫你有效地迭代資料。

import torch
import torch.utils.data as Data
torch.manual_seed(1)    # reproducible

BATCH_SIZE = 5      # 批訓練的資料個數

x = torch.linspace(1, 10, 10)       # x data (torch tensor)
y = torch.linspace(10, 1, 10)       # y data (torch tensor)

# 先轉換成 torch 能識別的 Dataset
torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)

# 把 dataset 放入 DataLoader
loader = Data.DataLoader(
    dataset=torch_dataset,      # torch TensorDataset format
    batch_size=BATCH_SIZE,      # mini batch size
    shuffle=True,               # 要不要打亂資料 (打亂比較好)
    num_workers=2,              # 多執行緒來讀資料
)

for epoch in range(3):   # 訓練所有!整套!資料 3 次
    for step, (batch_x, batch_y) in enumerate(loader):  # 每一步 loader 釋放一小批資料用來學習
        # 假設這裡就是你訓練的地方...

        # 打出來一些資料
        print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
              batch_x.numpy(), '| batch y: ', batch_y.numpy())

在神經網路裡面輸出值和輸入值都是Variable型別

利用pytorch實現迴歸擬合

建立一些假資料來模擬真實的情況. 比如一個一元二次函式: y = a * x^2 + b, 我們給 y 資料加上一點噪聲來更加真實的展示它。

#coding:utf-8
import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt
import torch.nn.functional as F

x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1)##torch.unsqueeze返回一個新的tensor,並且在1位置處新增一個新的維度，返回一個shape為(100,1)的tensor
y=x.pow(2)+0.2*torch.rand(x.size()) ##對ｙ新增一點噪音
x,y=Variable(x),Variable(y) ##用Variabvle包裹tensor方便以後求梯度,而且神經網路只能接受Variable型別資料


class Net(torch.nn.Module):
    def __init__(self,n_feature,n_hidden,n_output):##自定義各種層結構
        super(Net,self).__init__()
        self.hidden=torch.nn.Linear(n_feature,n_hidden)
        self.predict=torch.nn.Linear(n_hidden,n_output)

    def forward(self, x): ##搭建起神經網路
        x=F.relu(self.hidden(x)) ##x到達hiddenlayer並且經過relu啟用
        x=self.predict(x)##ｘ到達輸出層，輸出層不需要啟用，因為迴歸問題中預測值大小沒有區間限制，如果用啟用層那麼會截斷一部分。
        return x

##在神經網路裡面輸出值和輸入值都是Variable型別
net=Net(n_feature=1,n_hidden=10,n_output=1)
print net

optimizer=torch.optim.Adam(net.parameters(),lr=0.2) # 傳入 net 的所有引數, 學習率
loss_func=torch.nn.MSELoss()# 預測值和真實值的誤差計算公式 (均方差)

plt.ion()
plt.show()
for t in range(100):
    prediction=net(x)# 餵給 net 訓練資料 x, 輸出預測值

    loss=loss_func(prediction,y)  # 計算兩者的誤差

    optimizer.zero_grad()# 清空上一次反向更新所有引數時的殘留的引數梯度，因為每次在反向更新引數（BP演算法）時，都會保留上一次每個引數的梯度
    loss.backward()  ##根據誤差計算出每個引數的梯度
    optimizer.step()   # 以學習效率lr=0.2來更新引數，w=w-lr*alpha(loss)/alpha(w)


    if t%5 == 0:
        plt.cla()##動態畫圖時，每次畫出新的圖時，擦除上一時刻畫出的圖。
        plt.scatter(x.data.numpy(),y.data.numpy())
        plt.plot(x.data.numpy(),prediction.data.numpy(),'r-',lw=5)
        plt.pause(0.5)

利用pytorch實現分類

#coding:utf-8
import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt
import torch.nn.functional as F
import torch.nn as nn

n_data=torch.ones(100,2)##返回shape為(100,2)的全１張量
x0=torch.normal(2*n_data,1)##返回hape為(100,2)的張量，並且每個元素都是從均值為２，方差為１的正態分佈中隨機獲取。
y0=torch.zeros(100)##返回shape為(100,1)的全0張量
x1=torch.normal(-2*n_data,1)
y1=torch.ones(100)

# 注意 x, y 資料的資料形式是一定要像下面一樣 (torch.cat 是在合併資料)
x=torch.cat((x0,x1),0).type(torch.FloatTensor)# FloatTensor = 32-bit floating，dim=0表示在行的方向進行連線
y=torch.cat((y0,y1),).type(torch.LongTensor)# LongTensor = 64-bit integer，注意在pytorch分類問題中，標籤預設的要設定為LongTensor型別

x,y=Variable(x),Variable(y)##將Ｘ,ｙ tensor用Variable包裹起來，然後放進神經網路裡面


class Net(torch.nn.Module):
    def __init__(self,n_feature,n_hidden,n_output):
        super(Net,self).__init__()
        self.hidden=torch.nn.Linear(n_feature,n_hidden)
        self.predict=torch.nn.Linear(n_hidden,n_output)

    def forward(self, x):
        x=F.relu(self.hidden(x))
        x=self.predict(x)
        return x
net=Net(n_feature=2,n_hidden=10,n_output=2)
print net

optimizer=torch.optim.Adam(net.parameters(),lr=0.01)# 傳入 net 的所有引數, 學習率
loss_func=nn.CrossEntropyLoss()# 預測值和真實值的誤差計算公式 (交叉熵)

plt.ion()
plt.show()

##在神經網路裡面輸出值和輸入值都是Variable型別
for t in range(100):
    out=net(x)
    loss=loss_func(out,y)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if t%2==0:
        plt.cla()

        #F.softmax(out)得出二維的概率值，是個Variavle型別，1表示在列這個維度上得出每行的最大值，返回最大值和在這個行上的位置index local
        prediction=torch.max(F.softmax(out),1)[1]
        pred_y=prediction.data.numpy().squeeze()##.data先將Variable型別轉成tensor；.numpy再轉成numpy.array型別。
        ##squeeze是將多維資料壓縮後僅剩1維，那麼這裡面為什麼要加squeeze()呢？
        ## 因為下邊要計算accuracy=sum(pred_y==target_y)/float(200)，那麼pred_y和target_y要在格式上對齊
        ## target_y的shape為(200,)而prediction.data.numpy()的shape為(200,1)
        target_y=y.data.numpy()
        plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c=pred_y,s=100,lw=0,cmap='RdYlGn')
        accuracy=sum(pred_y==target_y)/float(200)
        print "accuracy:",accuracy
        plt.pause(0.2)
plt.ioff()
plt.show()

利用pytorch實現卷積神經網路(CNN)

#coding:utf-8
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import torch.nn as nn
import torchvision
import matplotlib.pyplot as plt

torch.manual_seed(1)

Epoche=1
Batch_size=50
LR=0.001
Download_mnist=False

train_data=torchvision.datasets.MNIST(
    root='./mnist/',
    train=True,
    transform=torchvision.transforms.ToTensor(),##將numpy.array轉成tensor型別，並且將每個畫素點從(0-255)壓縮到(0-1)
    download=Download_mnist
)
torchvision.datasets
print train_data.train_data.size()
print train_data.train_labels.size()
print type(train_data)
train_loader=torch.utils.data.DataLoader(dataset=train_data,batch_size=Batch_size,shuffle=True)

test_data=torchvision.datasets.MNIST(
    root='./mnist/',
    train=False,
    download=True,
    transform=torchvision.transforms.ToTensor()
)
#test_x=Variable(torch.unsqueeze(test_data.test_data,dim=1),volatile=True).type(torch.FloatTensor)[:20000]/255
print 'test_data:',test_data.test_data.size() #(10000L, 28L, 28L) (batch_szie,width,height)
test=torch.unsqueeze(test_data.test_data,dim=1)
print 'test:',test.size()   #轉成下面定義的神經網路輸入格式，輸入格式(10000L, 1L, 28L, 28L) (batch_size,in_channel,width,height)
test_x=Variable(test,volatile=True).type(torch.FloatTensor)[:20000]
test_y=test_data.test_labels[:20000]

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.conv1=nn.Sequential( #input shape(1,28,28) 此時不考慮batch_size
            nn.Conv2d(
                in_channels=1,#輸入的通道數目，這裡只有一個通道
                out_channels=16,##輸出16張特徵圖，
                kernel_size=5,##卷積核5×5
                stride=1,#每次移動的步長1
                padding=2,##padding=(kernel_size-stride)/2
            ),                       ##output shape(16,28,28)
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2), #output shape(16,14,14)
        )
        self.conv2=nn.Sequential(
            nn.Conv2d(16,32,5,1,2),  ##output shape(32,14,14)
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),   ##output shape(32,7,7)
        )
        self.out=nn.Linear(32*7*7,10)

    def forward(self,x):
        x=self.conv1(x)
        x=self.conv2(x)
        x=x.view(x.size(0),-1) ##x此時的shape(batch_size,32,7,7),x.size(0)=batch_size,x.view將其變為(batch_size,32*7*7)
        output=self.out(x)##　上面一步x.view將(batch_size,32,7,7)-->(batch_size,32*7*7)，32*7*7的格式滿足out輸入格式。
        return output

cnn=CNN()
print cnn

optimizer=torch.optim.Adam(cnn.parameters(),lr=LR)
loss_func=nn.CrossEntropyLoss()

##　神經網路裡面的輸入值和輸出值都必須是Variable型別
for epoch in range(Epoche):
    for step,(x,y) in enumerate(train_loader):
        b_x=Variable(x)
        b_y=Variable(y)

        output=cnn(b_x)
        optimizer.zero_grad()
        loss=loss_func(output,b_y)
        loss.backward()
        optimizer.step()

        if step%50==0:
            test_output=cnn(test_x)
            pred_y=torch.max(test_output,1)[1].data.squeeze()
            accuracy=sum(pred_y==test_y)/float(test_y.size(0))
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data[0], '| test accuracy: %.2f' % accuracy)

test_output = cnn(test_x[:10])
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

相關推薦

機器學習-->深度學習-->pytorch學習

本篇博文將大概的總結下深度學習框架pytorch的使用，其內容來自我在pytorch官方教程還有網上一些相關資料的總結，加上了一些自己的見解。 張量的說明 標量（Scalar）是隻有大小，沒有方向的量，如1，2，3等 向量（Vector）是有大小和方向

機器學習/深度學習 問題總結及解答

oos 情況 boost target rnn load 解答 兩種 blank 作者：原果 鏈接：https://www.nowcoder.com/discuss/71482 來源：牛客網 問題總結及資料鏈接 （1）機器學習部分 1 邏輯回歸部分 常

唐宇迪-機器學習/深度學習 系列課程福利大發送！不單優惠 還送機器學習必備實戰書籍！

機器學習 深度學習 人工智能 決勝AI就在今天 Hi同學們，給大家推薦一本機器學習的入門佳品：機器學習實戰。這本書可以說是我看過最通俗易懂的機器學習書籍了，並沒有上來直接闡述一些看著就頭疼的各種數學公式，而是以實際案例為出發點一步步帶領大家完成各個算法的建模與練習，人工智能必備No.1! 福利

入門機器（深度）學習的書籍及學習資料推薦

原理 .com 部分 nump 個人學習 概率論 並且 實驗 matplot （第一次寫博客，如有什麽地方寫得不對的，或者意見相左的，還請見諒！） 工作了一段時間，又重新回來讀書（本科計算機專業，第一個研究生是商科，現讀回了計算機專業）了，最開始想著走APP研發路線的，但是

【深度學習】Pytorch 學習筆記

chang www. ans 如何 ret == 筆記 etc finished 目錄 Pytorch Leture 05: Linear Rregression in the Pytorch Way Logistic Regression 邏輯回歸 - 二分類 Lect

機器學習 深度學習資料彙總（含文件，資料集，程式碼等） 三

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

github上值得關注的機器學習深度學習大牛（持續更新）

前言： 因為想搜相關內容發現搜到的基本上都是前端大牛（這可能是由於js是github上最受歡迎的語言），所以打算自己mark一下同時方便他人，於是寫下這篇博文，本文持續更新，如果有童鞋覺得有不錯的賬號也可以評論推薦給我~我也會更新上去~ 大牛：（排名不分先後） 一： Wes McKinn

機器學習：深度學習中的遷移學習

遷移學習也是最近機器學習領域很火熱的一個方向，尤其是基於深度學習的遷移學習。遷移學習，顧名思義，就是要遷移，有句成語叫觸類旁通，模型在某個任務上學習到知識，當遇到類似任務的時候，應該可以很快的把以前任務學到知識遷移過來。這是擬人化的描述，按照目前主流的 “資料驅動” 型的學習方式，我們所

機器學習 --- 深度前饋網路

對於某些問題，其特徵的表述極其困難，比如人臉的識別，其影響因素可能涉及到角度，光影，顏色，形狀等。深度學習旨在將原複雜的對映關係分解成一系列巢狀的簡單對映。   一、深度前饋網路簡要 深度前饋網路又稱多層感知機（MLP），對於分類器，函式  將輸入

未明學院：機器學習vs深度學習，如何規劃學習與就業路徑

自2016年以來，業界掀起一股人工智慧的熱潮。 2017年初，AlphaGo化身網路棋手Master擊敗聶衛平、柯潔、樸廷桓、井山裕太在內的數十位中日韓圍棋高手，在30秒一手的快棋對決中，無一落敗，拿下全勝，在棋界和科技界引發劇震。這使人們認識到AI(Artifical Intelligence

最新深度神經網路演算法機器學習深度學系列

深度神經網路演算法機器學習深度學系列視訊教程 (基礎1)Python程式入門視訊 課程Python介紹_壓縮 環境配置 配置Python環境 以及資料型別 字串String和變數 資料型別2整型_字串 資料結構列表 列表List元組tuple對比 元組 詞典 函式 函式 控制流 控制流 控制流 控制

機器學習/深度學習資源下載合集（持續更新...）

這篇文章轉載自「譯智社」的成員 —— 林夕的文章機器學習/深度學習資源下載集合（持續更新…）。如果你對人工智慧感興趣，歡迎關注公眾號 —— 譯智社。 從入門到進階，所用到機器學習資料，包括書、視訊、原始碼。文章首發於 Github，若下載資源請跳轉 Github. 文

機器學習、監督學習、非監督學習、強化學習、深度學習、遷移學習

文章目錄 機器學習（machine learning） 監督學習（supervised learning） 非監督學習（unsupervised learning） 強化學習（reinforcement learning） 傳統

機器學習/深度學習面試

                                &nb

機器學習&深度學習資料

注:機器學習資料篇目一共500條,篇目二開始更新 某些資料在中國訪問需要梯子.介紹:這是一篇介紹機器學習歷史的文章，介紹很全面，從感知機、神經網路、決策樹、SVM、Adaboost到隨機森林、Deep Learning.介紹:這是瑞士人工智慧實驗室Jurgen Schmidhuber寫的最新版本《神經網路與深

機器學習，大資料，深度學習 競賽網站，學習網站，演算法刷題網站

資料競賽類網站 Kaggle 阿里巴巴天池大資料比賽 DataCastle CCF大資料與計算智慧大賽 DataFountain Di-Tech演算法大賽 KDD-Cup KDnuggets Competition 全國高校雲端計算應用創

基本概念:人工智慧,機器學習,深度學習,強化學習的區別和簡介

人工智慧(Artificial Intelligence)是最早提出的一個專有名詞,早在50多年前就有幾個電腦科學家提出了人工智慧的概念,希望可以製造出可以和人類擁有類似智慧的機器.幾十年來這個概念被不斷的擴散至各行各業.當然也就帶來了各種濫用,一些帶了些許自動化演算法的軟體

python 基於機器學習—深度學習識別驗證碼

一、前言 開發環境：Anaconda | python 3.5 —pycharm / jupyter notebook 專案的整個識別流程： ① 驗證碼清理並生成訓練集樣本 ② 驗證碼特徵提取 ③ 擬

如何解決機器學習深度學習訓練集樣本不均衡的問題！

解決樣本不均衡的問題很多，主流的幾個如下： 1.樣本的過取樣和欠取樣。 2..使用多個分類器進行分類。 3.將二分類問題轉換成其他問題。 4.改變正負類別樣本在模型中的權重。 一、樣本的過取樣和欠取樣。 1.過取樣：將稀有類別的樣本進行復制，通過增加此稀有

2_初學者快速掌握主流深度學習框架Tensorflow、Keras、Pytorch學習程式碼（20181211）

初學者快速掌握主流深度學習框架Tensorflow、Keras、Pytorch學習程式碼 一、TensorFlow 1、資源地址： 2、資源介紹： 3、配置環境： 4、資源目錄： 二、Keras