亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

Python實現人工神經網絡(ANN)基本API

系統 2500 0
            
              
                # 簡單的人工神經網絡(ANN)設計
              
              

```python

              
                import
              
               numpy 
              
                as
              
               np

              
                import
              
               matplotlib
              
                .
              
              pyplot 
              
                as
              
               mp

              
                class
              
              
                ANNModel
              
              
                (
              
              
                )
              
              
                :
              
              
                def
              
              
                __init__
              
              
                (
              
              self
              
                )
              
              
                :
              
              
                # 隨機初始化權重[-1 1)
              
              
	    self
              
                .
              
              w0 
              
                =
              
              
                2
              
              
                *
              
               np
              
                .
              
              random
              
                .
              
              random
              
                (
              
              
                (
              
              
                2
              
              
                ,
              
              
                4
              
              
                )
              
              
                )
              
              
                -
              
              
                1
              
              
	    self
              
                .
              
              w1 
              
                =
              
              
                2
              
              
                *
              
               np
              
                .
              
              random
              
                .
              
              random
              
                (
              
              
                (
              
              
                4
              
              
                ,
              
              
                1
              
              
                )
              
              
                )
              
              
                -
              
              
                1
              
              
                # 學習率
              
              
	    self
              
                .
              
              lrate 
              
                =
              
              
                0.1
              
              
                # sigmiod 函數
              
              
                def
              
              
                active
              
              
                (
              
              self
              
                ,
              
               x
              
                )
              
              
                :
              
              
                return
              
              
                1
              
              
                /
              
              
                (
              
              
                1
              
              
                +
              
               np
              
                .
              
              exp
              
                (
              
              
                -
              
              x
              
                )
              
              
                )
              
              
                # sigmoid函數導函數
              
              
                def
              
              
                backward
              
              
                (
              
              self
              
                ,
              
               x
              
                )
              
              
                :
              
              
                return
              
               x 
              
                *
              
              
                (
              
              
                1
              
              
                -
              
               x
              
                )
              
              
                # 單層網路前向傳播
              
              
                def
              
              
                forward
              
              
                (
              
              self
              
                ,
              
               x
              
                ,
              
               w
              
                )
              
              
                :
              
              
                return
              
               np
              
                .
              
              dot
              
                (
              
              x
              
                ,
              
               w
              
                )
              
              
                def
              
              
                fit
              
              
                (
              
              self
              
                ,
              
               x
              
                )
              
              
                :
              
              
                for
              
               j 
              
                in
              
              
                range
              
              
                (
              
              
                10000
              
              
                )
              
              
                :
              
              
            l0 
              
                =
              
               x
            l1 
              
                =
              
               self
              
                .
              
              active
              
                (
              
              self
              
                .
              
              forward
              
                (
              
              l0
              
                ,
              
               self
              
                .
              
              w0
              
                )
              
              
                )
              
              
            l2 
              
                =
              
               self
              
                .
              
              active
              
                (
              
              self
              
                .
              
              forward
              
                (
              
              l1
              
                ,
              
               self
              
                .
              
              w1
              
                )
              
              
                )
              
              
                # 損失
              
              
            l2_error 
              
                =
              
               y 
              
                -
              
               l2
            
              
                if
              
              
                (
              
              j 
              
                %
              
              
                100
              
              
                )
              
              
                ==
              
              
                0
              
              
                :
              
              
                print
              
              
                (
              
              
                "Error:"
              
              
                +
              
              
                str
              
              
                (
              
              np
              
                .
              
              mean
              
                (
              
              np
              
                .
              
              
                abs
              
              
                (
              
              l2_error
              
                )
              
              
                )
              
              
                )
              
              
                )
              
              
            l2_delta 
              
                =
              
               l2_error 
              
                *
              
               self
              
                .
              
              backward
              
                (
              
              l2
              
                )
              
              
            self
              
                .
              
              w1 
              
                +=
              
               l1
              
                .
              
              T
              
                .
              
              dot
              
                (
              
              l2_delta 
              
                *
              
               self
              
                .
              
              lrate
              
                )
              
              
            l1_error 
              
                =
              
               l2_delta
              
                .
              
              dot
              
                (
              
              self
              
                .
              
              w1
              
                .
              
              T
              
                )
              
              
            l1_delta 
              
                =
              
               l1_error 
              
                *
              
               self
              
                .
              
              backward
              
                (
              
              l1
              
                )
              
              
            self
              
                .
              
              w0 
              
                +=
              
               l0
              
                .
              
              T
              
                .
              
              dot
              
                (
              
              l1_delta 
              
                *
              
               self
              
                .
              
              lrate
              
                )
              
              
                def
              
              
                predict
              
              
                (
              
              self
              
                ,
              
               x
              
                )
              
              
                :
              
              
        l0 
              
                =
              
               x
        l1 
              
                =
              
               self
              
                .
              
              active
              
                (
              
              self
              
                .
              
              forward
              
                (
              
              l0
              
                ,
              
               self
              
                .
              
              w0
              
                )
              
              
                )
              
              
        l2 
              
                =
              
               self
              
                .
              
              active
              
                (
              
              self
              
                .
              
              forward
              
                (
              
              l1
              
                ,
              
               self
              
                .
              
              w1
              
                )
              
              
                )
              
              
        result 
              
                =
              
               np
              
                .
              
              zeros_like
              
                (
              
              l2
              
                )
              
              
        result
              
                [
              
              l2
              
                >
              
              
                0.5
              
              
                ]
              
              
                =
              
              
                1
              
              
                return
              
               result

x 
              
                =
              
               np
              
                .
              
              array
              
                (
              
              
                [
              
              
                [
              
              
                3
              
              
                ,
              
              
                1
              
              
                ]
              
              
                ,
              
              
                [
              
              
                2
              
              
                ,
              
              
                5
              
              
                ]
              
              
                ,
              
              
                [
              
              
                1
              
              
                ,
              
              
                8
              
              
                ]
              
              
                ,
              
              
                [
              
              
                6
              
              
                ,
              
              
                4
              
              
                ]
              
              
                ,
              
              
                [
              
              
                5
              
              
                ,
              
              
                2
              
              
                ]
              
              
                ,
              
              
                [
              
              
                3
              
              
                ,
              
              
                5
              
              
                ]
              
              
                ,
              
              
                [
              
              
                4
              
              
                ,
              
              
                7
              
              
                ]
              
              
                ,
              
              
                [
              
              
                4
              
              
                ,
              
              
                -
              
              
                1
              
              
                ]
              
              
                ]
              
              
                )
              
              
y 
              
                =
              
               np
              
                .
              
              array
              
                (
              
              
                [
              
              
                0
              
              
                ,
              
              
                1
              
              
                ,
              
              
                1
              
              
                ,
              
              
                0
              
              
                ,
              
              
                0
              
              
                ,
              
              
                1
              
              
                ,
              
              
                1
              
              
                ,
              
              
                0
              
              
                ]
              
              
                )
              
              
                .
              
              reshape
              
                (
              
              
                -
              
              
                1
              
              
                ,
              
              
                1
              
              
                )
              
              
n 
              
                =
              
              
                500
              
              
l
              
                ,
              
               r 
              
                =
              
               x
              
                [
              
              
                :
              
              
                ,
              
              
                0
              
              
                ]
              
              
                .
              
              
                min
              
              
                (
              
              
                )
              
              
                -
              
              
                1
              
              
                ,
              
               x
              
                [
              
              
                :
              
              
                ,
              
              
                0
              
              
                ]
              
              
                .
              
              
                max
              
              
                (
              
              
                )
              
              
                +
              
              
                1
              
              
b
              
                ,
              
               t 
              
                =
              
               x
              
                [
              
              
                :
              
              
                ,
              
              
                1
              
              
                ]
              
              
                .
              
              
                min
              
              
                (
              
              
                )
              
              
                -
              
              
                1
              
              
                ,
              
               x
              
                [
              
              
                :
              
              
                ,
              
              
                1
              
              
                ]
              
              
                .
              
              
                max
              
              
                (
              
              
                )
              
              
                +
              
              
                1
              
              
grid_x 
              
                =
              
               np
              
                .
              
              meshgrid
              
                (
              
              np
              
                .
              
              linspace
              
                (
              
              l
              
                ,
              
               r
              
                ,
              
               n
              
                )
              
              
                ,
              
              np
              
                .
              
              linspace
              
                (
              
              b
              
                ,
              
               t
              
                ,
              
               n
              
                )
              
              
                )
              
              
flat_x 
              
                =
              
               np
              
                .
              
              column_stack
              
                (
              
              
                (
              
              grid_x
              
                [
              
              
                0
              
              
                ]
              
              
                .
              
              ravel
              
                (
              
              
                )
              
              
                ,
              
               grid_x
              
                [
              
              
                1
              
              
                ]
              
              
                .
              
              ravel
              
                (
              
              
                )
              
              
                )
              
              
                )
              
              
model 
              
                =
              
               ANNModel
              
                (
              
              
                )
              
              
model
              
                .
              
              fit
              
                (
              
              x
              
                )
              
              
flat_y 
              
                =
              
               model
              
                .
              
              predict
              
                (
              
              flat_x
              
                )
              
              
grid_y 
              
                =
              
               flat_y
              
                .
              
              reshape
              
                (
              
              grid_x
              
                [
              
              
                0
              
              
                ]
              
              
                .
              
              shape
              
                )
              
              
mp
              
                .
              
              figure
              
                (
              
              
                'SVM Linear Classification'
              
              
                ,
              
               facecolor
              
                =
              
              
                'lightgray'
              
              
                )
              
              
mp
              
                .
              
              title
              
                (
              
              
                'SVM Linear Classification'
              
              
                ,
              
               fontsize
              
                =
              
              
                20
              
              
                )
              
              
mp
              
                .
              
              xlabel
              
                (
              
              
                'x'
              
              
                ,
              
               fontsize
              
                =
              
              
                14
              
              
                )
              
              
mp
              
                .
              
              ylabel
              
                (
              
              
                'y'
              
              
                ,
              
               fontsize
              
                =
              
              
                14
              
              
                )
              
              
mp
              
                .
              
              tick_params
              
                (
              
              labelsize
              
                =
              
              
                10
              
              
                )
              
              
mp
              
                .
              
              pcolormesh
              
                (
              
              grid_x
              
                [
              
              
                0
              
              
                ]
              
              
                ,
              
               grid_x
              
                [
              
              
                1
              
              
                ]
              
              
                ,
              
               grid_y
              
                ,
              
               cmap
              
                =
              
              
                'gray'
              
              
                )
              
              
mp
              
                .
              
              scatter
              
                (
              
              x
              
                [
              
              
                :
              
              
                ,
              
              
                0
              
              
                ]
              
              
                ,
              
               x
              
                [
              
              
                :
              
              
                ,
              
              
                1
              
              
                ]
              
              
                ,
              
               c
              
                =
              
              y
              
                .
              
              ravel
              
                (
              
              
                )
              
              
                ,
              
               cmap
              
                =
              
              
                'brg'
              
              
                ,
              
               s
              
                =
              
              
                80
              
              
                )
              
              
mp
              
                .
              
              show
              
                (
              
              
                )
              
            
          
            
          

更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 欧美黄色网页 | 国产日韩一区二区三区在线观看 | 一级毛片特级毛片免费的 | 国产精品九九免费视频 | 五月婷婷激情 | 亚洲性综合| 国产日产欧产美一二三区 | 日韩伦理一区二区 | 亚洲精品久久久久久婷婷 | 国产欧美日韩精品一区二 | 嫩草嫩草55av | 在线观看精品国内福利视频 | 91宅男 | 99视频在线观看高清 | 天天干天天操天天做 | 久久影院朴妮唛 | 国产亚洲精品麻豆一区二区 | 免费中文字幕在线 | 波多野结衣一区二区三区在线观看 | 亚洲国产一 | 久久精品国产6699国产精 | 欧洲成人全免费视频网站 | 国产99网站| 毛片免费全部免费观看 | 暴力欧美娇小 videos | 欧美一级毛片免费播放器 | 久久久久久亚洲精品影院 | 亚洲综合网站久久久 | 夜夜艹日日干 | 国产在线拍 | 夜夜穞狠狠穞 | 一级毛片欧美一级日韩黄 | 久久777国产线看观看精品卜 | 久久久99精品久久久久久 | 国产亚洲精品久久久久久久软件 | 激情综合五月 | 欧美夜色 | 国产成人精品久久二区二区 | 欧美日韩一区二区不卡三区 | 国产精品第三页在线看 | 特级做人爱c级特级aav毛片 |