欧美三区_成人在线免费观看视频_欧美极品少妇xxxxⅹ免费视频_a级毛片免费播放_鲁一鲁中文字幕久久_亚洲一级特黄

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

系統 2566 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條評論
主站蜘蛛池模板: 日韩免费在线观看视频 | 天天色天天色 | 亚洲黄色色图 | 亚洲视频免费观看 | mmmwww| 欧美精品一区二区在线电影 | 亚洲精品一区久久久久久 | 国产一区二区欧美 | 欧美成人h版整片合集 | 亚洲第一精品在线 | 欧美系列在线播放 | 天天艹天天 | 夜夜爽99久久国产综合精品女不卡 | 国产成人18黄网站免费网站 | 亚洲经典三级 | 久久久精品视频免费看 | 精品亚洲永久免费精品 | 亚洲h| 九九久久九九久久 | 欧美日韩精品一区二区三区蜜桃 | 国产小视频免费在线观看 | 国产午夜精品一区二区三区 | 国产精品久久久久久久久久久新郎 | 国产精品国产a级 | 人人射人人草 | av播放在线| 国产亚洲精品久久久久久久久动漫 | 欧美成人a级在线视频 | av在线成人 | 欧美国产日韩在线 | 日韩精品免费在线视频 | 日朝欧美亚洲精品 | 欧美最爽乱淫视频免 | 久久亚洲精品中文字幕二区 | 色综合网站 | 亚洲国产精品久久久久久网站 | 欧美日韩亚洲视频 | 高清不卡一区二区 | 亚洲亚色 | av免费在线观看网站 | av在线色 |