中继器：还原衰弱的信号

 NetworkX是一个用Python语言开发的图论与复杂网络建模工具，内置了常用的图与复杂网络分析算法，可以方便的进行复杂网络数据分析、仿真建模等工作。网络上有阎老师的相关博客教程，在此表示敬意，点击进入。

        结合本人的使用经验，希望做到知其然而知其所以然的使用，提供相对傻瓜和全面的使用经验，也是自己的一笔知识财富积累。

       1.环境的安装

                 首先要安装python解释器，当然这是废话，但是安装的版本确有将就。先介绍几个部件：python解释器、networkx类库、还有使用支持networkx绘图的numpy和matplotlib，总共四个。

                 由于目前matplotlib只支持到python2.6解释器，所以还是下载python 2.6和各种类库2.6版本比较好。（更正：目前支持到了2.7版本）

                 下载链接：python 2.6  （一路点击即可）networkx-1.6-py2.6.egg 
 （等会儿介绍安装介个）numpy（一路）  matpotlib（win32-py2.6版本，一路next）

                 对于networkx第三方类库的安装，需要弄点东东。

                由于本人是win7系统，右键“以管理员身份运行”cmd，然后先安装ez_setup.py，下载完毕，进行安装。

                 

                 然后进行networkx的egg库的安装(关于egg库的安装详细解释，点击进入)

                 

                 安装完毕，进行测试。

                 打开python-command line,进行如图输入“import networkx as nx”+"print nx"，就有相关显示，如果没有成功，会提示不认识networkx类库的

要在google的搜索框内输入以下代码，就可以搜索到全球数以万计的摄像头直播。
inurl:"ViewerFrame?Mode="
 
相关报道：

　　近日，各博客和信息论坛上议论纷纷。因为有人发现只要在Google中进行简单的搜索就可以连入世界上超过1000个没有连接限制措施的监控摄像头。显然，摄像头的拥有者对此并不知情。

　　键入某个特定字段便可搜索到这些具有网页界面的网络摄像头。通过这些摄像头，其拥有者即可通过网络进行远程观察，甚至可以通过电脑控制摄像头进行变焦等操作。这些摄像头，分布在全球各个角落。

　　这条消息开始是在一个网络社区上张贴出来的，其后很快在周三和周四被转载到热门博
客论坛BoingBoing上。

　　其中一条查找字段，可以在Google上找出超过1500个有网络接入功能的监控摄像头。其中1000个由瑞典公司Axis Communications制造，500个由Panasonic生产。

　　根据两家公司的网站上的说明，摄像头的网络接入都提供了密码保护功能。Axis的摄像头更可以限制只能由特定的IP进行接入。但还不知道这些保护功能在产品出厂时是否默认为打开。在Panasonic网站的FAQ页面中，公司声明：“我们并没有收到客户对摄像头提供的安全保护的任何相关投诉。”

搜索：
http://www.google.com/search?q=inurl:%22ViewerFrame%3FMode ... =&c2coff=1&start=0&sa=N

小日本的洗衣店
http://sueyoshi.aa0.netvolante.jp/Vi ... =Motion&Language=1

http://24.39.100.161:82/ViewerFrame?Mode=Motion&Language=1
一个小日本的餐馆
http://improve.plala.jp/ViewerFrame?Mode=Motion&Resolution=640x480&Quali ... Size=STD&PresetOperation=Move&Language=1

http://miyakonojyo.aa1.netvolante.jp/Mul ... de=Motion&Language=1

http://ky-asuka.ddo.jp:3030/Viewe ... otion&Language=1

一个监控室：
http://candidcamera.ecasd.k12.wi.us/ViewerFrame?Mode=Motion


经典的学校（计算机/办公室/打印室）
http://163.136.136.17:8181/MultiCameraFrame?Mode=Motion

栗林山庄：
http://211.7.252.127:83/ViewerFrame?
Mode=Motion&Resolution=640x480&Quality=Standard&Interval=30&Size=STD&PresetOperation=Move&Language=1


可能需要JAVA支持 网络好象是IPV6的哦。。
http://ioc.jpn.ph:81/CgiStart?page=Multi&Language=1

十字路口：
http://219.117.243.105:8080/MultiCam ... Motion&Language=1


            
在搜索框上输入： “index of/ ” 　inurl:lib 

再按搜索你将进入许多图书馆，并且一定能下载自己喜欢的书籍。 


在搜索框上输入： “index of /” 　cnki 

再按搜索你就可以找到许多图书馆的CNKI、VIP、超星等入口！ 


在搜索框上输入：　“index of /” 　ppt 

再按搜索你就可以突破网站入口下载powerpint作品！ 


在搜索框上输入： “index of /” 　mp3 

再按搜索你就可以突破网站入口下载mp3、rm等影视作品！ 


在搜索框上输入：　“index of /” 　swf 

再按搜索你就可以突破网站入口下载flash作品！ 


在搜索框上输入： “index of /” 　要下载的软件名 

再按搜索你就可以突破网站入口下载软件！ 


注意引号应是英文的！ 


再透露一下，如果你输入： 


“index of /” 　AVI 

你会找到什么呢？同理，把AVI换为MPEG看看又会找到什么呢？呵呵！接下来不用我再教了吧？
            

            

            
近日消息，上周的网络论坛炸开了锅，原因是Google搜索能够使用户访问全球1000多个没有安全保护措施的监视摄像机，可在摄像机主人不知情下进行。

搜索URL中一些字符串就能够发现连接到互联网上的摄像机，看到原本只有摄像头主人才能够看到的内容，甚至能够指令摄像头改变角度，更适合观看。视频冲浪者已经利用这一方法对许多办公室和家庭进行了“偷窥”。

能够利用Google搜索“偷窥”的消息最先出现在一个论坛上，后来在上周三、上周四传播到了读者很多的BoingBoing网络日记系统中。过去，想通过监视用摄像机“偷窥”的人必须来到接收装置附近，利用特制天线获取来自无线摄像机的信号。

在网上传播的一个Google搜索字符串能够发现近1000部Axis公司生产的摄像机，另一个搜索字符串能够发现约500部由松下生产的摄像机。据二家公司的网站称，它们的网络摄像机都提供有密码保护功能，Axis还采取了只能从经过批准的IP地址访问 网络摄像机的技术。松下网站上的资料称，它的网络摄像机可能不适合在“机密应用”中使用。

可以在google查找
intitle:"Live View / - AXIS" | inurl:view/view.shtml
inurl:indexFrame.shtml Axis
intitle:"Live View / - AXIS"
intext:"MOBOTIX M1" intext:"Open Menu"
inurl:"ViewerFrame?Mode="
intitle:"WJ-NT104 Main Page"
intitle:snc-rz30 inurl:home/
            
            
            
        

 
1、Recursive Nerual Networks能够更好地体现每个词与词之间语法上的联系
这里我们选取的损失函数仍然是交叉熵函数

2、整个网络的结构如下图所示:



每个参数的更新时的梯队值如何计算,稍后再给大家计算相应的数学公式
这里先列出节点的合并规则


 
 

1、即假设将一句话中的词先两个合并，并通过神经网络计算出合并后的得分情况
2、然后找出合并后得分最高的两个词进行真正的合并，得到新的节点，其余节点不合并
3、将得到的新节点加入到下一轮两两合并的计算过程中，直至得到最终节点
下面是计算的代码：

'''
Created on 2017年10月5日

@author: weizhen
'''
# 一个简单的递归神经网络的实现，有着一个ReLU层和一个softmax层
# TODO : 必须要更新前向和后向传递函数
# 你可以通过执行 python rnn.py 方法来执行一个梯度检验
# 插入pdb.set_trace()  在你不确定将会发生什么的地方

import numpy as np
import collections
import pdb
import tree as treeM
import pickle

class RNN:
    
    def __init__(self, wvecDim, outputDim, numWords, mbSize=30, rho=1e-4):
        self.wvecDim = wvecDim
        self.outputDim = outputDim
        self.numWords = numWords
        self.mbSize = mbSize
        self.defaultVec = lambda : np.zeros((wvecDim,))
        self.rho = rho
    
    def initParams(self):
        np.random.seed(12341)
        
        # Word vectors
        self.L = 0.01 * np.random.randn(self.wvecDim, self.numWords)
        
        # Hidden layer parameters
        self.W = 0.01 * np.random.randn(self.wvecDim, 2 * self.wvecDim)
        self.b = np.zeros((self.wvecDim))
        
        # Softmax weights
        # note this is " U "in the notes and the handout...
        # there is a reason for the change in notation
        self.Ws = 0.01 * np.random.randn(self.outputDim, self.wvecDim)
        self.bs = np.zeros((self.outputDim))
        
        self.stack = [self.L, self.W, self.b, self.Ws, self.bs]
        
        # Gradients
        self.dW = np.empty(self.W.shape)
        self.db = np.empty((self.wvecDim))
        self.dWs = np.empty(self.Ws.shape)
        self.dbs = np.empty((self.outputDim))
        
    def costAndGrad(self, mbdata, test=False):
        """
                    每一个datum在minibatch里边都是一个树
                    前向计算每一个树,反向传播到每一个树
                    返回值:
            cost:
                                    梯度：w.r.t W,Ws,b,bs
                                    以上变量的梯度都是在稀疏形式存储的
                                    或者是以测试状态下的
            Returns:
                cost,correctArray,guessArray,total
        """
        cost = 0.0
        correct = []
        guess = []
        total = 0.0
        
        self.L, self.W, self.b, self.Ws, self.bs = self.stack
        # 初始化所有梯度都是0
        self.dW[:] = 0
        self.db[:] = 0
        self.dWs[:] = 0
        self.dbs[:] = 0
        self.dL = collections.defaultdict(self.defaultVec)
        
        # 在每一个batch中前向计算每一个tree
        for tree in mbdata:
            c, tot = self.forwardProp(tree.root, correct, guess)
            cost += c
            total += tot
        if test:
            return (1. / len(mbdata)) * cost, correct, guess, total
        
        # 在每一个batch上进行反向传播
        for tree in mbdata:
            self.backProp(tree.root)
        
        # 通过mb的大小来计算损失和梯度
        scale = (1. / self.mbSize)
        for v in self.dL.values():
            v *= scale
        
        # 添加L2正则化项
        cost += (self.rho / 2) * np.sum(self.W ** 2)
        cost += (self.rho / 2) * np.sum(self.Ws ** 2)
        
        return scale * cost, [self.dL, scale * (self.dW + self.rho * self.W), scale * self.db, scale * (self.dWs + self.rho * self.Ws), scale * self.dbs]
    
    def forwardProp(self, node, correct=[], guess=[]):
        """损失应该是一个不断更新的变量，总损失是我们需要用在准确率报告里边的数据"""
        cost = total = 0.0
        # 下面实现递归神经网络前向传播的函数
        # 你应该更新 node.probs, node.hActsl,node.fprop,and cost
        # node :你当前节点是在语法树上的
        # correct : 这是一个不断更新的标记真值的列表
        # guess: 这是一个不断更新的猜测我们的模型会预测为哪一个结果的列表
        #       (我们会同时使用正确的和猜测的值来构造我们的混淆矩阵)
        L = self.L
        # 隐藏层的参数
        W = self.W
        b = self.b
        
        # Softmax 权重
        Ws = self.Ws
        bs = self.bs
        
        if node.isLeaf:
            node.hActsl = L[:, node.word]
        else:
            if not node.left.fprop:
                cost_left, total_left = self.forwardProp(node.left, correct, guess)
                cost += cost_left
                total += total_left
            if not node.right.fprop:
                cost_right, total_right = self.forwardProp(node.right, correct, guess)
                cost += cost_right
                total += total_right
            
            node.hActsl = W.dot(np.hstack((node.left.hActsl, node.right.hActsl))) + b
            node.hActsl[node.hActsl < 0] = 0
        
        x = Ws.dot(node.hActsl) + bs
        x -= np.max(x)
        node.probs = np.exp(x) / np.sum(np.exp(x))
        
        correct += [node.label]
        guess += [np.argmax(node.probs)]
        
        cost -= np.log(node.probs[node.label])
        
        node.fprop = True
        
        return cost, total + 1
    
    def backProp(self, node, error=None):
        """
                    实现递归神经网络的反向传播函数
                    应该更新 self.dWs, self.dbs, self.dW, self.db, and self.dL[node.word] 相关地
        node:你在语法树种的当前节点
        error:误差从之前一个迭代过程中传递进来的
        """
        # 清空节点
        node.fprop = False
        
        L = self.L
        # 隐藏节点的参数
        W = self.W
        b = self.b
        
        # Softmax层的权重
        Ws = self.Ws
        bs = self.bs
        
        error_this = node.probs
        error_this[node.label] -= 1.0
        delta = Ws.T.dot(error_this)
        
        self.dWs += np.outer(error_this, node.hActsl)
        self.dbs += error_this
        
        if error is not None:
            delta += error
        
        delta[node.hActsl == 0] = 0
        
        if node.isLeaf:
            self.dL[node.word] += delta
        else:
            self.dW += np.outer(delta, np.hstack([node.left.hActsl, node.right.hActsl]))
            self.db += delta
            
            delta = np.dot(self.W.T, delta)
            self.backProp(node.left, delta[:self.wvecDim])
            self.backProp(node.right, delta[self.wvecDim:])
    
    def updateParams(self, scale, update, log=False):
        """
                    如下这样更新参数
                    p:=p-scale*update
                    如果log是真的，输出根节点的均方误差，并且更新根节点的值
        """
        if log:
            for P, dP in zip(self.stack[1:], update[1:]):
                pRMS = np.sqrt(np.mean(P ** 2))
                dpRMS = np.sqrt(np.mean((scale * dP) ** 2))
                print("weight rms=%f -- update rms=%f" % (pRMS, dpRMS))
        self.stack[1:] = [P + scale * dP for P, dP in zip(self.stack[1:], update[1:])]
        
        # 解决词典并且进行稀疏的更新
        dL = update[0]
        for j in dL.iterkeys():
            self.L[:, j] += scale.dL[j]
    
    def toFile(self, fid):
        pickle.dump(self.stack, fid)
    
    def fromFile(self, fid):
        self.stack = pickle.load(fid)
    
    def check_grad(self, data, epsilon=1e-6):
        cost, grad = self.costAndGrad(data)
        
        err1 = 0.0
        count = 0.0
        print("Checking dW...")
        for W, dW in zip(self.stack[1:], grad[1:]):
            W = W[..., None]
            dW = dW[..., None]
            for i in range(W.shape[0]):
                for j in range(W.shape[1]):
                    W[i, j] += epsilon
                    costP, _ = self.costAndGrad(data)
                    W[i, j] -= epsilon
                    numGrad = (costP - cost) / epsilon
                    err = np.abs(dW[i, j] - numGrad)
                    err1 += err
                    count += 1
        if 0.001 > err1 / count:
            print("Grad Check Passed for dW")
        else:
            print("Grad Check Failed for dW:Sum of Error=%.9f" % (err1 / count))
        
        
        # check dL separately since dict
        dL = grad[0]
        L = self.stack[0]
        err2 = 0.0
        count = 0.0
        print("Checking dL...")
        for j in dL.keys():
            for i in range(L.shape[0]):
                L[i, j] += epsilon
                costP, _ = self.costAndGrad(data)
                L[i, j] -= epsilon
                numGrad = (costP - cost) / epsilon
                err = np.abs(dL[j][i] - numGrad)
                err2 += err
                count += 1
        if 0.001 > err2 / count:
            print("Grad Check Passed for dL")
        else:
            print("Grad Check Failed for dL: Sum of Error = %.9f" % (err2 / count))

if __name__ == '__main__':

    train = treeM.loadTrees()
    numW = len(treeM.loadWordMap())
    
    wvecDim = 10
    outputDim = 5
    
    rnn = RNN(wvecDim, outputDim, numW, mbSize=4)
    rnn.initParams()
    
    mbData = train[:4]
    print("Numerical gradient check...")
    rnn.check_grad(mbData)
        

 下面部分是构造节点的python文件tree.py
在进行计算时需要先运行tree.py文件进行tree结构的生成，然后进行合并计算

import collections
import pickle
UNK = 'UNK'
# This file contains the dataset in a useful way. We populate a list of Trees to train/test our Neural Nets such that each Tree contains any number of Node objects.

# The best way to get a feel for how these objects are used in the program is to drop pdb.set_trace() in a few places throughout the codebase
# to see how the trees are used.. look where loadtrees() is called etc..


class Node: # a node in the tree
    def __init__(self,label,word=None):
        self.label = label 
        self.word = word # NOT a word vector, but index into L.. i.e. wvec = L[:,node.word]
        self.parent = None # reference to parent
        self.left = None # reference to left child
        self.right = None # reference to right child
        self.isLeaf = False # true if I am a leaf (could have probably derived this from if I have a word)
        self.fprop = False # true if we have finished performing fowardprop on this node (note, there are many ways to implement the recursion.. some might not require this flag)
        self.hActs1 = None # h1 from the handout
        self.hActs2 = None # h2 from the handout (only used for RNN2)
        self.probs = None # yhat

class Tree:

    def __init__(self,treeString,openChar='(',closeChar=')'):
        tokens = []
        self.open = '('
        self.close = ')'
        for toks in treeString.strip().split():
            tokens += list(toks)
        self.root = self.parse(tokens)

    def parse(self, tokens, parent=None):
        assert tokens[0] == self.open, "Malformed tree"
        assert tokens[-1] == self.close, "Malformed tree"

        split = 2 # position after open and label
        countOpen = countClose = 0

        if tokens[split] == self.open: 
            countOpen += 1
            split += 1
        # Find where left child and right child split
        while countOpen != countClose:
            if tokens[split] == self.open:
                countOpen += 1
            if tokens[split] == self.close:
                countClose += 1
            split += 1

        # New node
        node = Node(int(tokens[1])) # zero index labels

        node.parent = parent 

        # leaf Node
        if countOpen == 0:
            node.word = ''.join(tokens[2:-1]).lower() # lower case?
            node.isLeaf = True
            return node

        node.left = self.parse(tokens[2:split],parent=node)
        node.right = self.parse(tokens[split:-1],parent=node)

        return node

        

def leftTraverse(root,nodeFn=None,args=None):
    """
    Recursive function traverses tree
    from left to right. 
    Calls nodeFn at each node
    """
    nodeFn(root,args)
    if root.left is not None:
        leftTraverse(root.left,nodeFn,args)
    if root.right is not None:
        leftTraverse(root.right,nodeFn,args)


def countWords(node,words):
    if node.isLeaf:
        words[node.word] += 1

def clearFprop(node,words):
    node.fprop = False

def mapWords(node,wordMap):
    if node.isLeaf:
        if node.word not in wordMap:
            node.word = wordMap[UNK]
        else:
            node.word = wordMap[node.word]
    

def loadWordMap():
    with open('wordMap.bin','rb') as fid:
        return pickle.load(fid)

def buildWordMap():
    """
    Builds map of all words in training set
    to integer values.
    """


    file = 'trees/train.txt'
    print("Reading trees to build word map..")
    with open(file,'r') as fid:
        trees = [Tree(l) for l in fid.readlines()]

    print("Counting words to give each word an index..")
    
    words = collections.defaultdict(int)
    for tree in trees:
        leftTraverse(tree.root,nodeFn=countWords,args=words)
    
    wordMap = dict(zip(words.keys(),range(len(words))))
    wordMap[UNK] = len(words) # Add unknown as word
    
    print("Saving wordMap to wordMap.bin")
    with open('wordMap.bin','wb') as fid:
        pickle.dump(wordMap,fid)

def loadTrees(dataSet='train'):
    """
    Loads training trees. Maps leaf node words to word ids.
    """
    wordMap = loadWordMap()
    file = 'trees/%s.txt'%dataSet
    print("Loading %sing trees.."%dataSet)
    with open(file,'r') as fid:
        trees = [Tree(l) for l in fid.readlines()]
    for tree in trees:
        leftTraverse(tree.root,nodeFn=mapWords,args=wordMap)
    return trees
      
if __name__=='__main__':
    buildWordMap()
    
    train = loadTrees()

    print("Now you can do something with this list of trees!")

 
更详细的代码请参考github:
https://github.com/weizhenzhao/cs224d_problem_set3