神經網路之文字情感分析（二）

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

Projet 2

在Project 1 中，我們學習瞭如何處理和統計reviews
基於上一個Project”一個蘿蔔一個坑”的思想，我們將文字進行了數字化，使得文字可以作為輸入進行訓練
在Project 2中我們將構建一個兩層的神經網路，並進行訓練

import numpy as np
import sys
import time
import pandas as pd

# 讀取資料
reviews = pd.read_csv('reviews.txt', header=None)
labels = pd.read_csv('labels.txt', header=None 
)

構建神經網路

構建一個兩層的神經網路
注意：輸入層到隱層不使用任何啟用函式，只要隱層到輸出層才使用啟用函式（為什麼這麼做？後面的Project會提到）

class SentimentNetwork(object):
    def __init__(self, reviews, labels, hidden_nodes=10, learning_rate = 0.1):
        """
        引數：
            reviews(dataFrame), 用於訓練
            labels(dataFrame)， 用於訓練
            hidden_nodes(int), 隱層的個數
            learning_rate(double)，學習步長
        """ 


        np.random.seed(1)

        self.pre_process_data(reviews, labels)

        self.init_network(len(self.review_vocab), hidden_nodes, 1, learning_rate)

    def pre_process_data(self, reviews, labels):
        """
        預處理資料，統計reviews中出現的所有單詞，並且生成word2index
        """

        # 統計reviews中出現的所有單詞， 

        review_vocab = set()
        for review in reviews.values:
            word = review[0].split(' ')
            review_vocab.update(word)

        self.review_vocab = list(review_vocab)

        # 統計labels中所有出現的label(其實在這裡，就+1和-1兩種)
        label_vocab = set()
        for label in labels.values:
            label_vocab.add(label[0])
        self.label_vocab = list(label_vocab)

        # 構建word2idx，給每個單詞安排一個"門牌號"
        self.word2idx = dict()
        for idx, word in enumerate(self.review_vocab):
            self.word2idx[word] = idx

    def init_network(self, input_nodes, hidden_nodes, output_nodes, learning_rate):
        """
        初始化網路的引數
        """
        self.learning_rate = learning_rate
        self.input_nodes = input_nodes
        self.hidden_nodes = hidden_nodes
        self.output_nodes = output_nodes

        self.weights_0_1 = np.random.normal( 0.0, self.input_nodes**-0.5, (self.input_nodes, self.hidden_nodes) )
        self.weights_1_2 = np.random.normal( 0.0, self.hidden_nodes**-0.5, (self.hidden_nodes, self.output_nodes) )

        self.layer_0 = np.zeros((1, self.input_nodes))

    def update_input_layer(self, review):
        """
        對review進行數字化處理，並將結果存放到self.layer_0中，也就是輸入層
        """
        self.layer_0 *= 0
        for word in review.split(' '):
            if word.lower() in self.word2idx:
                idx = self.word2idx[word.lower()]
                # 統計單詞出現的次數，作為輸入
                self.layer_0[0,idx] += 1

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_output_2_derivative(self, output):
        return output * (1 - output)

    def get_target_for_label(self,label):
        if label == 'positive':
            return 1
        else:
            return 0

    def train(self, training_reviews, training_label):
        assert(len(training_reviews) == len(training_label))

        correct_so_far = 0

        start = time.time()

        # 進行訓練
        for i in range(len(training_reviews)):
            review = training_reviews.iloc[i,0]
            label = training_label.iloc[i,0]

            self.update_input_layer(review)

            layer_1_i = np.dot( self.layer_0, self.weights_0_1 )
            layer_1_o = layer_1_i

            layer_2_i = np.dot( layer_1_o, self.weights_1_2 )
            layer_2_o = self.sigmoid( layer_2_i )

            layer_2_error = layer_2_o - self.get_target_for_label(label)
            layer_2_delta = layer_2_error * self.sigmoid_output_2_derivative(layer_2_o)

            layer_1_error = np.dot( layer_2_delta, self.weights_1_2.T )
            layer_1_delta = layer_1_error
            # 權重更新
            self.weights_1_2 -= np.dot(layer_1_o.T, layer_2_delta) * self.learning_rate
            self.weights_0_1 -= np.dot(self.layer_0.T, layer_1_delta) * self.learning_rate

            if(layer_2_o >= 0.5 and label=='positive'):
                correct_so_far += 1
            elif(layer_2_o < 0.5 and label=='negative'):
                correct_so_far += 1

            elapsed_time = float(time.time() - start)
            reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0

            sys.stdout.write("\rProgress:" + str(100 * i/float(len(training_reviews)))[:4] \
                             + "% Speed(reviews/sec):" + str(reviews_per_second)[0:5] \
                             + " #Correct:" + str(correct_so_far) + " #Trained:" + str(i+1) \
                             + " Training Accuracy:" + str(correct_so_far * 100 / float(i+1))[:4] + "%")
            if(i % 2500 == 0):
                print("")

    def test(self, testing_reviews, testing_labels):
        assert(len(testing_reviews) == len(testing_labels))

        correct = 0

        start = time.time()

        for i in range(len(testing_reviews)):
            review = testing_reviews.iloc[i,0]
            label = testing_labels.iloc[i,0]

            pred = self.run(review)
            if pred == label:
                correct += 1

            elapsed_time = float(time.time() - start)
            reviews_per_second = i / elapsed_time if elapsed_time > 0 else 0

            sys.stdout.write("\rProgress:" + str(100 * i/float(len(testing_reviews)))[:4] \
                             + "% Speed(reviews/sec):" + str(reviews_per_second)[0:5] \
                             + " #Correct:" + str(correct) + " #Tested:" + str(i+1) \
                             + " Testing Accuracy:" + str(correct * 100 / float(i+1))[:4] + "%")


    def run(self, review):
        self.update_input_layer(review)

        layer_1_i = np.dot( self.layer_0, self.weights_0_1 )
        layer_1_o = layer_1_i

        layer_2_i = np.dot( layer_1_o, self.weights_1_2 )
        layer_2_o = self.sigmoid( layer_2_i )            
        if layer_2_o >= 0.5:
            return 'positive'
        else:
            return 'negative'

mlp = SentimentNetwork(reviews, labels)

mlp.train(reviews[:-1000], labels[:-1000])

Progress:0.0% Speed(reviews/sec):0 #Correct:0 #Trained:1 Training Accuracy:0.0%
Progress:10.4% Speed(reviews/sec):101.5 #Correct:1246 #Trained:2501 Training Accuracy:49.8%
Progress:20.8% Speed(reviews/sec):103.1 #Correct:2496 #Trained:5001 Training Accuracy:49.9%
Progress:31.2% Speed(reviews/sec):103.4 #Correct:3746 #Trained:7501 Training Accuracy:49.9%
Progress:41.6% Speed(reviews/sec):101.3 #Correct:4996 #Trained:10001 Training Accuracy:49.9%
Progress:52.0% Speed(reviews/sec):99.30 #Correct:6246 #Trained:12501 Training Accuracy:49.9%
Progress:62.5% Speed(reviews/sec):98.82 #Correct:7496 #Trained:15001 Training Accuracy:49.9%
Progress:72.9% Speed(reviews/sec):98.57 #Correct:8746 #Trained:17501 Training Accuracy:49.9%
Progress:83.3% Speed(reviews/sec):98.86 #Correct:9996 #Trained:20001 Training Accuracy:49.9%
Progress:93.7% Speed(reviews/sec):99.27 #Correct:11246 #Trained:22501 Training Accuracy:49.9%
Progress:99.9% Speed(reviews/sec):99.44 #Correct:11995 #Trained:24000 Training Accuracy:49.9%

從輸出的訓練資訊來看，始終在50%徘徊，也就是說根本沒有進展，對於這種情況，我們首先要做的就是試一試調小learning_rate

mlp = SentimentNetwork(reviews, labels, learning_rate=0.01)

mlp.train(reviews[:-1000], labels[:-1000])

Progress:0.0% Speed(reviews/sec):0.0 #Correct:0 #Trained:1 Training Accuracy:0.0%
Progress:10.4% Speed(reviews/sec):103.6 #Correct:1329 #Trained:2501 Training Accuracy:53.1%
Progress:20.8% Speed(reviews/sec):103.5 #Correct:2923 #Trained:5001 Training Accuracy:58.4%
Progress:31.2% Speed(reviews/sec):99.96 #Correct:4593 #Trained:7501 Training Accuracy:61.2%
Progress:41.6% Speed(reviews/sec):97.92 #Correct:6341 #Trained:10001 Training Accuracy:63.4%
Progress:52.0% Speed(reviews/sec):97.22 #Correct:8105 #Trained:12501 Training Accuracy:64.8%
Progress:62.5% Speed(reviews/sec):97.64 #Correct:9889 #Trained:15001 Training Accuracy:65.9%
Progress:72.9% Speed(reviews/sec):97.91 #Correct:11671 #Trained:17501 Training Accuracy:66.6%
Progress:83.3% Speed(reviews/sec):97.92 #Correct:13530 #Trained:20001 Training Accuracy:67.6%
Progress:93.7% Speed(reviews/sec):97.92 #Correct:15384 #Trained:22501 Training Accuracy:68.3%
Progress:99.9% Speed(reviews/sec):97.82 #Correct:16531 #Trained:24000 Training Accuracy:68.8%

mlp.test(reviews[-1000:], labels[-1000:])

Progress:99.9% Speed(reviews/sec):861.2 #Correct:747 #Tested:1000 Testing Accuracy:74.7%

End Project 2

通過訓練，我們的神經網路能達到60%以上的準確率，至少比猜的結果要好，不錯，這是一個好的開始。
準確率只有70多，可提升的空間還有很大，在下一個Project，我們將進行分析如何提高準確率

神經網路之文字情感分析（二）

Projet 2 在Project 1 中，我們學習瞭如何處理和統計reviews 基於上一個Project”一個蘿蔔一個坑”的思想，我們將文字進行了數字化，使得文字可以作為輸入進行訓練在Project 2中我們將構建一個兩層的神經網路，並進行訓練

cs231n斯坦福基於卷積神經網路的CV學習筆記（二）神經網路訓練細節

五，神經網路注意點part1 例項：邏輯迴歸二層神經網路訓練函式使用權重w和偏差值biase計算出第一個隱含層h，然後計算損失，評分，進行反向傳播回去多種常用啟用函式（一般預設max（0，x）），如sigmoid函式具有飽和區梯度0，非零點中心，計算x複

Wireshark之FTP協議分析（二）

以實際抓包來分析ftp協議，加深理解。環境： win7電腦+linux裝置，linux裝置為ftp服務端，win7電腦通過WinSCP的ftp主動方式（我得版本winscp預設是被動方式，需要從高階選項修改）來連線ftp服務端。過程：電腦（192.168.3.2

基於機器學習的NLP情感分析（二）---- 分類問題

基於機器學習的NLP情感分析（二）—- 分類問題前文提到了如何把一個文字轉換為相應的詞向量，本文討論的是如何進行分類。 feature相關性首先，需要看看我之前選出來的feature，是否能夠滿足需求。這裡其實有很多引數沒有顯示出來

資料探勘演算法之聚類分析（二）canopy演算法

canopy是聚類演算法的一種實現它是一種快速，簡單，但是不太準確的聚類演算法 canopy通過兩個人為確定的閾值t1，t2來對資料進行計算，可以達到將一堆混亂的資料分類成有一定規則的n個數據堆由於canopy演算法本身的目的只是將混亂的資料劃分成大概的幾個類別，所以它

資料探勘——基於R文字情感分析（2）

姑且算是搞定了這個。最後使用的是在twitter中搜索。因為callback url的關係，之前一直無法直接搜尋twitter內容，今天直接把callback url刪除了就成功了。推薦兩個很好的

AndroidO audio系統之audioflinger啟動分析（二）

1. audioflinger建立過程在Android8.0的音訊系統中，AudioFlinger是一個C++的Binder服務，執行在HAL程序中，它是在audioserver.c //frameworks/av/media/audioserver/

（O）Telephony分析之通話流程分析（二）撥打電話流程分析（上）

撥打電話，是從通話的撥號盤開始的，而撥號盤的介面是在DialpadFragment，因此，需要從這個地方進行分析一.撥號盤介面撥號流程 public void onClick(View view) { ...... if (resId == R.id.dia

Java併發之AQS原始碼分析（二）

我在Java併發之AQS原始碼分析（一）這篇文章中，從原始碼的角度深度剖析了 AQS 獨佔鎖模式下的獲取鎖與釋放鎖的邏輯，如果你把

Java安全之Commons Collections1分析（二）

# Java安全之Commons Collections1分析（二） ## 0x00 前言續上篇文，繼續除錯cc鏈。在上篇文章除錯的cc鏈其實並不是一個完整的鏈。只是使用了幾個方法的的互相呼叫彈出一個計算器。 [Java安全之Commons Collections1分析（一）](https://www

ArcGIS網路分析之Silverlight客戶端最近設施點分析（二）

在上一篇中說了如何實現最近路徑分析，本篇將討論如何實現最近設施點分析。最近設施點分析實際上和路徑分析有些相識，實現的過程基本一致，不同的是引數的設定，選用的分析圖層為最近設施點網路分析圖層，一般形式為： http://<伺服器名或ip地址>/ArcGIS/re

文字挖掘之情感分析（一）

一、文字挖掘文字挖掘則是對文字進行處理，從中挖掘出來文字中有用的資訊和關鍵的規則，在文字挖掘領域應用最往廣泛的是對文字進行分類和聚類，其挖掘的方法分為無監督學習和監督學習。文字挖掘還可以劃分為7大類：關鍵詞提取、文字摘要、文字主題模型、文字聚類

linux設備驅動之misc驅動框架源碼分析（二）

linux驅動開發misc設備驅動1、misc_open函數分析該函數在driver/char/misc.c中，misc.c是驅動框架實現的，這裏面的misc_Open函數是misc驅動框架為應用層提供的一個打開misc設備的一個接口。 1、首先我們要知道在misc.c中的misc_init函數

Glide原始碼分析（二）——從用法來看之load&into方法

上一篇，我們分析了with方法，文章連結： https://blog.csdn.net/qq_36391075/article/details/82833260 在with方法中，進行了Glide的初始化，建立了RequesManger，並且綁定了生命週期，最終返回了一個Reques

zigbee 之ZStack-2.5.1a原始碼分析（二）無線接收控制LED

本文描述ZStack-2.5.1a 模板及無線接收移植相關內容。 main HAL_BOARD_INIT // HAL_TURN_OFF_LED1 InitBoard HalDriverInit HalAdcInit

BIGEMAP教程之Arcgis進行DEM資料進行水文分析（二）

第一步：需要的工具 1. BIGEMPA地圖下載器 3. ARCGIS 第二步驟：通過BIGEMAP下載高程資料

《用Python玩轉資料》專案—線性迴歸分析入門之波士頓房價預測（二）

接上一部分，此篇將用tensorflow建立神經網路，對波士頓房價資料進行簡單建模預測。二、使用tensorflow擬合boston房價datasets 1、資料處理依然利用sklearn來分訓練集和測試集。 2、使用一層隱藏層的簡單網路，試下來用當前這組超引數收斂較快，準確率也可以。 3、啟用函式

《用Python玩轉數據》項目—線性回歸分析入門之波士頓房價預測（二）

store mil ima 超參數 eval app lac on() break 接上一部分，此篇將用tensorflow建立神經網絡，對波士頓房價數據進行簡單建模預測。二、使用tensorflow擬合boston房價datasets 1、數據處理依然利用sklearn

神經網路之過擬合（附程式碼）

摘要監督機器學習問題無非就是“minimizeyour error while regularizing your parameters”，也就是在規則化引數的同時最小化誤差。最小化誤差是為了讓我們的模型擬合我們的訓練資料，而規則化引數是防止我們的模型過分擬合我們的訓練資料

神經網路之文字情感分析（二）

Projet 2

構建神經網路

End Project 2

相關推薦