机器学习实战源代码

机器学习实战源代码
机器学习实战源代码

机器学习实战

2 K-近邻算法 (3)

2.1 kNN.py (3)

2.2 createDist.py (5)

2.3 createDist2.py (7)

2.4 createFirstPlot.py (8)

3 决策树 (9)

3.1 treePlotter.py (9)

3.2 trees.py (11)

4 基于概率论的分类方法:朴素贝叶斯 (13)

4.1 bayes.py (13)

4.2 create2Normal.py (17)

4.3 monoDemo.py (18)

5 Logistic回归 (19)

5.1 logRegres.py (19)

5.2 plot2D.py (21)

5.3 plotGD.py (22)

5.4 plotSDerror.py (24)

5.5 sigmoidPlot.py (25)

6 支持向量机 (26)

6.1 svmMLiA.py (26)

6.2 notLinSeperable.py (34)

6.3 plotRBF.py (36)

6.4 plotSupportV ectors.py (37)

7 利用AdaBoost元算法提高分类性能 (38)

7.1 adaboost.py (38)

7.2 old_adaboost.py (41)

8 预测数值型数据:回归 (43)

8.1 regression.py (43)

8.2 Old_regression.py (48)

9 树回归 (53)

9.1 regTrees.py (53)

9.2 treeExplore.py (56)

10 利用K-均值聚类算法对未标注数据分组 (58)

10.1 kMeans.py (58)

11 使用Apriori算法进行关联分析 (61)

11.1 apriori.py (61)

12 使用FP-growth算法来高效分析频繁项集 (65)

12.1 fpGrowth.py (65)

13 利用PCA来简化数据 (68)

13.1 pca.py (68)

13.2 createFig1.py (69)

13.2 createFig2.py (70)

13.3 createFig3 (70)

13.4 createFig4.py (72)

14 利用SVD简化数据 (72)

14.1 svdRec.py (72)

15 大数据与MapReduce (75)

15.1 mrMean.py (75)

15.2 mrMeanMapper.py (76)

15.3 mrMeanReducer.py (76)

15.4 mrSVM.py (77)

15.5 mrSVMkickStart.py (79)

15.6 pegasos.py (79)

15.7 proximalSVM.py (81)

15.8 py27dbg.py (82)

15.9 wc.py (83)

2 K-近邻算法

2.1 kNN.py

'''

Created on Sep 16, 2010

kNN: k Nearest Neighbors

Input: inX: vector to compare to existing dataset (1xN)

dataSet: size m data set of known vectors (NxM)

labels: data set labels (1xM vector)

k: number of neighbors to use for comparison (should be an odd number)

Output: the most popular class label

@author: pbharrin

'''

from numpy import *

import operator

from os import listdir

def classify0(inX, dataSet, labels, k):

dataSetSize = dataSet.shape[0]

diffMat = tile(inX, (dataSetSize,1)) - dataSet

sqDiffMat = diffMat**2

sqDistances = sqDiffMat.sum(axis=1)

distances = sqDistances**0.5

sortedDistIndicies = distances.argsort()

classCount={}

for i in range(k):

voteIlabel = labels[sortedDistIndicies[i]]

classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1

sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True) return sortedClassCount[0][0]

def createDataSet():

group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])

labels = ['A','A','B','B']

return group, labels

def file2matrix(filename):

fr = open(filename)

numberOfLines = len(fr.readlines()) #get the number of lines in the file

returnMat = zeros((numberOfLines,3)) #prepare matrix to return

classLabelV ector = [] #prepare labels return

fr = open(filename)

index = 0

for line in fr.readlines():

line = line.strip()

listFromLine = line.split('\t')

returnMat[index,:] = listFromLine[0:3]

classLabelV ector.append(int(listFromLine[-1]))

index += 1

return returnMat,classLabelV ector

def autoNorm(dataSet):

minV als = dataSet.min(0)

maxV als = dataSet.max(0)

ranges = maxV als - minV als

normDataSet = zeros(shape(dataSet))

m = dataSet.shape[0]

normDataSet = dataSet - tile(minV als, (m,1))

normDataSet = normDataSet/tile(ranges, (m,1)) #element wise divide

return normDataSet, ranges, minV als

def datingClassTest():

hoRatio = 0.50 #hold out 10%

datingDataMat,datingLabels = file2matrix('datingTestSet2.txt') #load data setfrom file

normMat, ranges, minV als = autoNorm(datingDataMat)

m = normMat.shape[0]

numTestVecs = int(m*hoRatio)

errorCount = 0.0

for i in range(numTestV ecs):

classifierResult = classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestV ecs:m],3) print "the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i])

if (classifierResult != datingLabels[i]): errorCount += 1.0

print "the total error rate is: %f" % (errorCount/float(numTestV ecs))

print errorCount

def img2vector(filename):

returnV ect = zeros((1,1024))

fr = open(filename)

for i in range(32):

lineStr = fr.readline()

for j in range(32):

returnV ect[0,32*i+j] = int(lineStr[j])

return returnV ect

def handwritingClassTest():

hwLabels = []

trainingFileList = listdir('trainingDigits') #load the training set

m = len(trainingFileList)

trainingMat = zeros((m,1024))

for i in range(m):

fileNameStr = trainingFileList[i]

fileStr = fileNameStr.split('.')[0] #take off .txt

classNumStr = int(fileStr.split('_')[0])

hwLabels.append(classNumStr)

trainingMat[i,:] = img2vector('trainingDigits/%s' % fileNameStr)

testFileList = listdir('testDigits') #iterate through the test set

errorCount = 0.0

mTest = len(testFileList)

for i in range(mTest):

fileNameStr = testFileList[i]

fileStr = fileNameStr.split('.')[0] #take off .txt

classNumStr = int(fileStr.split('_')[0])

vectorUnderTest = img2vector('testDigits/%s' % fileNameStr)

classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)

print "the classifier came back with: %d, the real answer is: %d" % (classifierResult, classNumStr)

if (classifierResult != classNumStr): errorCount += 1.0

print "\nthe total number of errors is: %d" % errorCount

print "\nthe total error rate is: %f" % (errorCount/float(mTest))

2.2 createDist.py

'''

Created on Oct 6, 2010

@author: Peter

'''

from numpy import *

import matplotlib

import matplotlib.pyplot as plt

from matplotlib.patches import Rectangle

n = 1000 #number of points to create

xcord = zeros((n))

ycord = zeros((n))

markers =[]

colors =[]

fw = open('testSet.txt','w')

for i in range(n):

[r0,r1] = random.standard_normal(2)

myClass = random.uniform(0,1)

if (myClass <= 0.16):

fFlyer = random.uniform(22000, 60000)

tats = 3 + 1.6*r1

markers.append(20)

colors.append(2.1)

classLabel = 1 #'didntLike'

print ("%d, %f, class1") % (fFlyer, tats)

elif ((myClass > 0.16) and (myClass <= 0.33)):

fFlyer = 6000*r0 + 70000

tats = 10 + 3*r1 + 2*r0

markers.append(20)

colors.append(1.1)

classLabel = 1 #'didntLike'

print ("%d, %f, class1") % (fFlyer, tats)

elif ((myClass > 0.33) and (myClass <= 0.66)):

fFlyer = 5000*r0 + 10000

tats = 3 + 2.8*r1

markers.append(30)

colors.append(1.1)

classLabel = 2 #'smallDoses'

print ("%d, %f, class2") % (fFlyer, tats)

else:

fFlyer = 10000*r0 + 35000

tats = 10 + 2.0*r1

markers.append(50)

colors.append(0.1)

classLabel = 3 #'largeDoses'

print ("%d, %f, class3") % (fFlyer, tats)

if (tats < 0): tats =0

if (fFlyer < 0): fFlyer =0

xcord[i] = fFlyer; ycord[i]=tats

fw.write("%d\t%f\t%f\t%d\n" % (fFlyer, tats, random.uniform(0.0, 1.7), classLabel))

fw.close()

fig = plt.figure()

ax = fig.add_subplot(111)

ax.scatter(xcord,ycord, c=colors, s=markers)

type1 = ax.scatter([-10], [-10], s=20, c='red')

type2 = ax.scatter([-10], [-15], s=30, c='green')

type3 = ax.scatter([-10], [-20], s=50, c='blue')

ax.legend([type1, type2, type3], ["Class 1", "Class 2", "Class 3"], loc=2)

#ax.axis([-5000,100000,-2,25])

plt.xlabel('Frequent Flyier Miles Earned Per Year')

plt.ylabel('Percentage of Body Covered By Tatoos') plt.show()

2.3 createDist2.py

'''

Created on Oct 6, 2010

@author: Peter

'''

from numpy import *

import matplotlib

import matplotlib.pyplot as plt

from matplotlib.patches import Rectangle

n = 1000 #number of points to create

xcord1 = []; ycord1 = []

xcord2 = []; ycord2 = []

xcord3 = []; ycord3 = []

markers =[]

colors =[]

fw = open('testSet.txt','w')

for i in range(n):

[r0,r1] = random.standard_normal(2)

myClass = random.uniform(0,1)

if (myClass <= 0.16):

fFlyer = random.uniform(22000, 60000)

tats = 3 + 1.6*r1

markers.append(20)

colors.append(2.1)

classLabel = 1 #'didntLike'

xcord1.append(fFlyer); ycord1.append(tats) elif ((myClass > 0.16) and (myClass <= 0.33)): fFlyer = 6000*r0 + 70000

tats = 10 + 3*r1 + 2*r0

markers.append(20)

colors.append(1.1)

classLabel = 1 #'didntLike'

if (tats < 0): tats =0

if (fFlyer < 0): fFlyer =0

xcord1.append(fFlyer); ycord1.append(tats) elif ((myClass > 0.33) and (myClass <= 0.66)): fFlyer = 5000*r0 + 10000

tats = 3 + 2.8*r1

markers.append(30)

colors.append(1.1)

classLabel = 2 #'smallDoses'

if (tats < 0): tats =0

if (fFlyer < 0): fFlyer =0

xcord2.append(fFlyer); ycord2.append(tats)

else:

fFlyer = 10000*r0 + 35000

tats = 10 + 2.0*r1

markers.append(50)

colors.append(0.1)

classLabel = 3 #'largeDoses'

if (tats < 0): tats =0

if (fFlyer < 0): fFlyer =0

xcord3.append(fFlyer); ycord3.append(tats)

fw.close()

fig = plt.figure()

ax = fig.add_subplot(111)

#ax.scatter(xcord,ycord, c=colors, s=markers)

type1 = ax.scatter(xcord1, ycord1, s=20, c='red')

type2 = ax.scatter(xcord2, ycord2, s=30, c='green')

type3 = ax.scatter(xcord3, ycord3, s=50, c='blue')

ax.legend([type1, type2, type3], ["Did Not Like", "Liked in Small Doses", "Liked in Large Doses"], loc=2)

ax.axis([-5000,100000,-2,25])

plt.xlabel('Frequent Flyier Miles Earned Per Year')

plt.ylabel('Percentage of Time Spent Playing Video Games')

plt.show()

2.4 createFirstPlot.py

'''

Created on Oct 27, 2010

@author: Peter

'''

from numpy import *

import kNN

import matplotlib

import matplotlib.pyplot as plt

fig = plt.figure()

ax = fig.add_subplot(111)

datingDataMat,datingLabels = kNN.file2matrix('datingTestSet.txt')

#ax.scatter(datingDataMat[:,1], datingDataMat[:,2])

ax.scatter(datingDataMat[:,1], datingDataMat[:,2], 15.0*array(datingLabels), 15.0*array(datingLabels))

ax.axis([-2,25,-0.2,2.0])

plt.xlabel('Percentage of Time Spent Playing Video Games')

plt.ylabel('Liters of Ice Cream Consumed Per Week')

plt.show()

3 决策树

3.1 treePlotter.py

'''

Created on Oct 14, 2010

@author: Peter Harrington

'''

import matplotlib.pyplot as plt

decisionNode = dict(boxstyle="sawtooth", fc="0.8")

leafNode = dict(boxstyle="round4", fc="0.8")

arrow_args = dict(arrowstyle="<-")

def getNumLeafs(myTree):

numLeafs = 0

firstStr = myTree.keys()[0]

secondDict = myTree[firstStr]

for key in secondDict.keys():

if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes

numLeafs += getNumLeafs(secondDict[key])

else: numLeafs +=1

return numLeafs

def getTreeDepth(myTree):

maxDepth = 0

firstStr = myTree.keys()[0]

secondDict = myTree[firstStr]

for key in secondDict.keys():

if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes

thisDepth = 1 + getTreeDepth(secondDict[key])

else: thisDepth = 1

if thisDepth > maxDepth: maxDepth = thisDepth

return maxDepth

def plotNode(nodeTxt, centerPt, parentPt, nodeType):

createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',

xytext=centerPt, textcoords='axes fraction',

va="center", ha="center", bbox=nodeType, arrowprops=arrow_args )

def plotMidText(cntrPt, parentPt, txtString):

xMid = (parentPt[0]-cntrPt[0])/2.0 + cntrPt[0]

yMid = (parentPt[1]-cntrPt[1])/2.0 + cntrPt[1]

createPlot.ax1.text(xMid, yMid, txtString, va="center", ha="center", rotation=30)

def plotTree(myTree, parentPt, nodeTxt):#if the first key tells you what feat was split on numLeafs = getNumLeafs(myTree) #this determines the x width of this tree

depth = getTreeDepth(myTree)

firstStr = myTree.keys()[0] #the text label for this node should be this

cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)

plotMidText(cntrPt, parentPt, nodeTxt)

plotNode(firstStr, cntrPt, parentPt, decisionNode)

secondDict = myTree[firstStr]

plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD

for key in secondDict.keys():

if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes

plotTree(secondDict[key],cntrPt,str(key)) #recursion

else: #it's a leaf node print the leaf node

plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW

plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)

plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))

plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD

#if you do get a dictonary you know it's a tree, and the first element will be another dict

def createPlot(inTree):

fig = plt.figure(1, facecolor='white')

fig.clf()

axprops = dict(xticks=[], yticks=[])

createPlot.ax1 = plt.subplot(111, frameon=False, **axprops) #no ticks

#createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses

plotTree.totalW = float(getNumLeafs(inTree))

plotTree.totalD = float(getTreeDepth(inTree))

plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0;

plotTree(inTree, (0.5,1.0), '')

plt.show()

#def createPlot():

# fig = plt.figure(1, facecolor='white')

# fig.clf()

# createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses

# plotNode('a decision node', (0.5, 0.1), (0.1, 0.5), decisionNode)

# plotNode('a leaf node', (0.8, 0.1), (0.3, 0.8), leafNode)

# plt.show()

def retrieveTree(i):

listOfTrees =[{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},

{'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}

]

return listOfTrees[i]

#createPlot(thisTree)

3.2 trees.py

'''

Created on Oct 12, 2010

Decision Tree Source Code for Machine Learning in Action Ch. 3

@author: Peter Harrington

'''

from math import log

import operator

def createDataSet():

dataSet = [[1, 1, 'yes'],

[1, 1, 'yes'],

[1, 0, 'no'],

[0, 1, 'no'],

[0, 1, 'no']]

labels = ['no surfacing','flippers']

#change to discrete values

return dataSet, labels

def calcShannonEnt(dataSet):

numEntries = len(dataSet)

labelCounts = {}

for featV ec in dataSet: #the the number of unique elements and their occurance

currentLabel = featVec[-1]

if currentLabel not in labelCounts.keys(): labelCounts[currentLabel] = 0

labelCounts[currentLabel] += 1

shannonEnt = 0.0

for key in labelCounts:

prob = float(labelCounts[key])/numEntries

shannonEnt -= prob * log(prob,2) #log base 2

return shannonEnt

def splitDataSet(dataSet, axis, value):

retDataSet = []

for featV ec in dataSet:

if featV ec[axis] == value:

reducedFeatV ec = featV ec[:axis] #chop out axis used for splitting

reducedFeatV ec.extend(featVec[axis+1:])

retDataSet.append(reducedFeatVec)

return retDataSet

def chooseBestFeatureToSplit(dataSet):

numFeatures = len(dataSet[0]) - 1 #the last column is used for the labels

baseEntropy = calcShannonEnt(dataSet)

bestInfoGain = 0.0; bestFeature = -1

for i in range(numFeatures): #iterate over all the features

featList = [example[i] for example in dataSet]#create a list of all the examples of this feature

uniqueV als = set(featList) #get a set of unique values

newEntropy = 0.0

for value in uniqueV als:

subDataSet = splitDataSet(dataSet, i, value)

prob = len(subDataSet)/float(len(dataSet))

newEntropy += prob * calcShannonEnt(subDataSet)

infoGain = baseEntropy - newEntropy #calculate the info gain; ie reduction in entropy

if (infoGain > bestInfoGain): #compare this to the best gain so far

bestInfoGain = infoGain #if better than current best, set to best

bestFeature = i

return bestFeature #returns an integer

def majorityCnt(classList):

classCount={}

for vote in classList:

if vote not in classCount.keys(): classCount[vote] = 0

classCount[vote] += 1

sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True) return sortedClassCount[0][0]

def createTree(dataSet,labels):

classList = [example[-1] for example in dataSet]

if classList.count(classList[0]) == len(classList):

return classList[0]#stop splitting when all of the classes are equal

if len(dataSet[0]) == 1: #stop splitting when there are no more features in dataSet return majorityCnt(classList)

bestFeat = chooseBestFeatureToSplit(dataSet)

bestFeatLabel = labels[bestFeat]

myTree = {bestFeatLabel:{}}

del(labels[bestFeat])

featV alues = [example[bestFeat] for example in dataSet]

uniqueV als = set(featV alues)

for value in uniqueV als:

subLabels = labels[:] #copy all of labels, so trees don't mess up existing labels

myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)

return myTree

def classify(inputTree,featLabels,testV ec):

firstStr = inputTree.keys()[0]

secondDict = inputTree[firstStr]

featIndex = featLabels.index(firstStr)

key = testV ec[featIndex]

valueOfFeat = secondDict[key]

if isinstance(valueOfFeat, dict):

classLabel = classify(valueOfFeat, featLabels, testVec)

else: classLabel = valueOfFeat

return classLabel

def storeTree(inputTree,filename):

import pickle

fw = open(filename,'w')

pickle.dump(inputTree,fw)

fw.close()

def grabTree(filename):

import pickle

fr = open(filename)

return pickle.load(fr)

4 基于概率论的分类方法:朴素贝叶斯

4.1 bayes.py

'''

Created on Oct 19, 2010

@author: Peter

'''

from numpy import *

def loadDataSet():

postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],

['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],

['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],

['stop', 'posting', 'stupid', 'worthless', 'garbage'],

['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],

['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']] classV ec = [0,1,0,1,0,1] #1 is abusive, 0 not

return postingList,classVec

def createV ocabList(dataSet):

vocabSet = set([]) #create empty set

for document in dataSet:

vocabSet = vocabSet | set(document) #union of the two sets return list(vocabSet)

def setOfWords2Vec(vocabList, inputSet):

returnV ec = [0]*len(vocabList)

for word in inputSet:

if word in vocabList:

returnV ec[vocabList.index(word)] = 1

else: print "the word: %s is not in my V ocabulary!" % word return returnV ec

def trainNB0(trainMatrix,trainCategory):

numTrainDocs = len(trainMatrix)

numWords = len(trainMatrix[0])

pAbusive = sum(trainCategory)/float(numTrainDocs)

p0Num = ones(numWords); p1Num = ones(numWords) #change to ones() p0Denom = 2.0; p1Denom = 2.0 #change to 2.0

for i in range(numTrainDocs):

if trainCategory[i] == 1:

p1Num += trainMatrix[i]

p1Denom += sum(trainMatrix[i])

else:

p0Num += trainMatrix[i]

p0Denom += sum(trainMatrix[i])

p1V ect = log(p1Num/p1Denom) #change to log()

p0V ect = log(p0Num/p0Denom) #change to log()

return p0Vect,p1V ect,pAbusive

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):

p1 = sum(vec2Classify * p1Vec) + log(pClass1) #element-wise mult

p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)

if p1 > p0:

return 1

else:

return 0

def bagOfWords2V ecMN(vocabList, inputSet):

returnV ec = [0]*len(vocabList)

for word in inputSet:

if word in vocabList:

returnV ec[vocabList.index(word)] += 1

return returnV ec

def testingNB():

listOPosts,listClasses = loadDataSet()

myV ocabList = createV ocabList(listOPosts)

trainMat=[]

for postinDoc in listOPosts:

trainMat.append(setOfWords2V ec(myV ocabList, postinDoc)) p0V,p1V,pAb = trainNB0(array(trainMat),array(listClasses))

testEntry = ['love', 'my', 'dalmation']

thisDoc = array(setOfWords2V ec(myV ocabList, testEntry))

print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb) testEntry = ['stupid', 'garbage']

thisDoc = array(setOfWords2V ec(myV ocabList, testEntry))

print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)

def textParse(bigString): #input is big string, #output is word list import re

listOfTokens = re.split(r'\W*', bigString)

return [tok.lower() for tok in listOfTokens if len(tok) > 2]

def spamTest():

docList=[]; classList = []; fullText =[]

for i in range(1,26):

wordList = textParse(open('email/spam/%d.txt' % i).read())

docList.append(wordList)

fullText.extend(wordList)

classList.append(1)

wordList = textParse(open('email/ham/%d.txt' % i).read())

docList.append(wordList)

fullText.extend(wordList)

classList.append(0)

vocabList = createV ocabList(docList)#create vocabulary

trainingSet = range(50); testSet=[] #create test set

for i in range(10):

randIndex = int(random.uniform(0,len(trainingSet)))

testSet.append(trainingSet[randIndex])

trainMat=[]; trainClasses = []

for docIndex in trainingSet:#train the classifier (get probs) trainNB0

trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))

trainClasses.append(classList[docIndex])

p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))

errorCount = 0

for docIndex in testSet: #classify the remaining items

wordV ector = bagOfWords2V ecMN(vocabList, docList[docIndex])

if classifyNB(array(wordV ector),p0V,p1V,pSpam) != classList[docIndex]: errorCount += 1

print "classification error",docList[docIndex]

print 'the error rate is: ',float(errorCount)/len(testSet)

#return vocabList,fullText

def calcMostFreq(vocabList,fullText):

import operator

freqDict = {}

for token in vocabList:

freqDict[token]=fullText.count(token)

sortedFreq = sorted(freqDict.iteritems(), key=operator.itemgetter(1), reverse=True) return sortedFreq[:30]

def localWords(feed1,feed0):

import feedparser

docList=[]; classList = []; fullText =[]

minLen = min(len(feed1['entries']),len(feed0['entries']))

for i in range(minLen):

wordList = textParse(feed1['entries'][i]['summary'])

docList.append(wordList)

fullText.extend(wordList)

classList.append(1) #NY is class 1

wordList = textParse(feed0['entries'][i]['summary'])

docList.append(wordList)

fullText.extend(wordList)

classList.append(0)

vocabList = createV ocabList(docList)#create vocabulary

top30Words = calcMostFreq(vocabList,fullText) #remove top 30 words

for pairW in top30Words:

if pairW[0] in vocabList: vocabList.remove(pairW[0])

trainingSet = range(2*minLen); testSet=[] #create test set

for i in range(20):

randIndex = int(random.uniform(0,len(trainingSet)))

testSet.append(trainingSet[randIndex])

trainMat=[]; trainClasses = []

for docIndex in trainingSet:#train the classifier (get probs) trainNB0

trainMat.append(bagOfWords2VecMN(vocabList, docList[docIndex]))

trainClasses.append(classList[docIndex])

p0V,p1V,pSpam = trainNB0(array(trainMat),array(trainClasses))

errorCount = 0

for docIndex in testSet: #classify the remaining items

wordV ector = bagOfWords2V ecMN(vocabList, docList[docIndex])

if classifyNB(array(wordV ector),p0V,p1V,pSpam) != classList[docIndex]:

errorCount += 1

print 'the error rate is: ',float(errorCount)/len(testSet)

return vocabList,p0V,p1V

def getTopWords(ny,sf):

import operator

vocabList,p0V,p1V=localWords(ny,sf)

topNY=[]; topSF=[]

for i in range(len(p0V)):

if p0V[i] > -6.0 : topSF.append((vocabList[i],p0V[i]))

if p1V[i] > -6.0 : topNY.append((vocabList[i],p1V[i]))

sortedSF = sorted(topSF, key=lambda pair: pair[1], reverse=True)

print "SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**"

for item in sortedSF:

print item[0]

sortedNY = sorted(topNY, key=lambda pair: pair[1], reverse=True)

print

"NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY** "

for item in sortedNY:

print item[0]

4.2 create2Normal.py

'''

Created on Oct 6, 2010

@author: Peter

'''

from numpy import *

import matplotlib

import matplotlib.pyplot as plt

n = 1000 #number of points to create

xcord0 = []

ycord0 = []

ycord1 = []

markers =[]

colors =[]

fw = open('testSet.txt','w')

for i in range(n):

[r0,r1] = random.standard_normal(2)

myClass = random.uniform(0,1)

if (myClass <= 0.5):

fFlyer = r0 + 9.0

tats = 1.0*r1 + fFlyer - 9.0

xcord0.append(fFlyer)

ycord0.append(tats)

else:

fFlyer = r0 + 2.0

tats = r1+fFlyer - 2.0

xcord1.append(fFlyer)

ycord1.append(tats)

#fw.write("%f\t%f\t%d\n" % (fFlyer, tats, classLabel))

fw.close()

fig = plt.figure()

ax = fig.add_subplot(111)

#ax.scatter(xcord,ycord, c=colors, s=markers)

ax.scatter(xcord0,ycord0, marker='^', s=90)

ax.scatter(xcord1,ycord1, marker='o', s=50, c='red')

plt.plot([0,1], label='going up')

plt.show()

4.3 monoDemo.py

'''

Created on Oct 6, 2010

Shows montonocity of a function and the log of that function @author: Peter

'''

from numpy import *

import matplotlib

import matplotlib.pyplot as plt

t = arange(0.0, 0.5, 0.01)

s = sin(2*pi*t)

logS = log(s)

fig = plt.figure()

ax = fig.add_subplot(211)

ax.set_ylabel('f(x)')

ax.set_xlabel('x')

ax = fig.add_subplot(212)

ax.plot(t,logS)

ax.set_ylabel('ln(f(x))')

ax.set_xlabel('x')

plt.show()

5 Logistic回归

5.1 logRegres.py

'''

Created on Oct 27, 2010

Logistic Regression Working Module

@author: Peter

'''

from numpy import *

def loadDataSet():

dataMat = []; labelMat = []

fr = open('testSet.txt')

for line in fr.readlines():

lineArr = line.strip().split()

dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])

labelMat.append(int(lineArr[2]))

return dataMat,labelMat

def sigmoid(inX):

return 1.0/(1+exp(-inX))

def gradAscent(dataMatIn, classLabels):

dataMatrix = mat(dataMatIn) #convert to NumPy matrix

labelMat = mat(classLabels).transpose() #convert to NumPy matrix

m,n = shape(dataMatrix)

alpha = 0.001

maxCycles = 500

weights = ones((n,1))

for k in range(maxCycles): #heavy on matrix operations

h = sigmoid(dataMatrix*weights) #matrix mult

error = (labelMat - h) #vector subtraction

weights = weights + alpha * dataMatrix.transpose()* error #matrix mult return weights

def plotBestFit(weights):

import matplotlib.pyplot as plt

dataMat,labelMat=loadDataSet()

dataArr = array(dataMat)

n = shape(dataArr)[0]

xcord1 = []; ycord1 = []

xcord2 = []; ycord2 = []

for i in range(n):

if int(labelMat[i])== 1:

xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])

else:

xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])

fig = plt.figure()

ax = fig.add_subplot(111)

ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')

ax.scatter(xcord2, ycord2, s=30, c='green')

x = arange(-3.0, 3.0, 0.1)

y = (-weights[0]-weights[1]*x)/weights[2]

ax.plot(x, y)

plt.xlabel('X1'); plt.ylabel('X2');

plt.show()

def stocGradAscent0(dataMatrix, classLabels):

m,n = shape(dataMatrix)

alpha = 0.01

weights = ones(n) #initialize to all ones

for i in range(m):

h = sigmoid(sum(dataMatrix[i]*weights))

error = classLabels[i] - h

weights = weights + alpha * error * dataMatrix[i]

return weights

def stocGradAscent1(dataMatrix, classLabels, numIter=150):

m,n = shape(dataMatrix)

weights = ones(n) #initialize to all ones

for j in range(numIter):

dataIndex = range(m)

for i in range(m):

alpha = 4/(1.0+j+i)+0.0001 #apha decreases with iteration, does not

randIndex = int(random.uniform(0,len(dataIndex)))#go to 0 because of the constant

h = sigmoid(sum(dataMatrix[randIndex]*weights))

error = classLabels[randIndex] - h

weights = weights + alpha * error * dataMatrix[randIndex]

del(dataIndex[randIndex])

return weights

机器人的动力学控制

机器人的动力学控制 The dynamics of robot control 自123班 庞悦 3120411054

机器人的动力学控制 摘要:机器人动力学是对机器人机构的力和运动之间关系与平衡进行研究的学科。机器人动力学是复杂的动力学系统,对处理物体的动态响应取决于机器人动力学模型和控制算法。机器人动力学主要研究动力学正问题和动力学逆问题两个方面,需要采用严密的系统方法来分析机器人动力学特性。本文使用MATLAB 来对两关节机器人模型进行仿真,进而对两关节机器人进行轨迹规划,来举例说明独立PD 控制在机器人动力学控制中的重要作用。 Abstract: for the robot dynamics is to study the relation between the force and movement and balance of the subject.Robot dynamics is a complex dynamic system, on the dynamic response of the processing object depending on the robot dynamics model and control algorithm.Kinetics of robot research dynamics problem and inverse problem of two aspects, the need to adopt strict system method for the analysis of robot dynamics.This article USES MATLAB to simulate two joints, the robot, in turn, the two joints, the robot trajectory planning, to illustrate the independent PD control plays an important part in robot dynamic control. 一 动力学概念 机器人的动力学主要是研究动力学正问题和动力学逆问题两个方面,再进一步研究机器人的关节力矩,使机器人的机械臂运动到指定位臵,其控制算法一共有三种:独立PD 控制,前馈控制和计算力矩控制,本文主要介绍独立PD 控制。 动力学方程:)()(),()(q G q F q q q C q q M +++=? ????τ

工业机器人静力及动力学分析

注:1)2008年春季讲课用;2)带下划线的黑体字为板书内容;3)公式及带波浪线的部分为必讲内容第3章工业机器人静力学及动力学分析 3.1 引言 在第2章中,我们只讨论了工业机器人的位移关系,还未涉及到力、速度、加速度。由理论力学的知识我们知道,动力学研究的是物体的运动和受力之间的关系。要对工业机器人进行合理的设计与性能分析,在使用中实现动态性能良好的实时控制,就需要对工业机器人的动力学进行分析。在本章中,我们将介绍工业机器人在实际作业中遇到的静力学和动力学问题,为以后“工业机器人控制”等章的学习打下一个基础。 在后面的叙述中,我们所说的力或力矩都是“广义的”,包括力和力矩。 工业机器人作业时,在工业机器人与环境之间存在着相互作用力。外界对手部(或末端操作器)的作用力将导致各关节产生相应的作用力。假定工业机器人各关节“锁住”,关节的“锁定用”力与外界环境施加给手部的作用力取得静力学平衡。工业机器人静力学就是分析手部上的作用力与各关节“锁定用”力之间的平衡关系,从而根据外界环境在手部上的作用力求出各关节的“锁定用”力,或者根据已知的关节驱动力求解出手部的输出力。 关节的驱动力与手部施加的力之间的关系是工业机器人操作臂力控制的基础,也是利用达朗贝尔原理解决工业机器人动力学问题的基础。 工业机器人动力学问题有两类:(1)动力学正问题——已知关节的驱动力,求工业机器人系统相应的运动参数,包括关节位移、速度和加速度。(2)动力学逆问题——已知运动轨迹点上的关节位移、速度和加速度,求出相应的关节力矩。 研究工业机器人动力学的目的是多方面的。动力学正问题对工业机器人运动仿真是非常有用的。动力学逆问题对实现工业机器人实时控制是相当有用的。利用动力学模型,实现最优控制,以期达到良好的动态性能和最优指标。 工业机器人动力学模型主要用于工业机器人的设计和离线编程。在设计中需根据连杆质量、运动学和动力学参数,传动机构特征和负载大小进行动态仿真,对其性能进行分析,从而决定工业机器人的结构参数和传动方案,验算设计方案的合理性和可行性。在离线编程时,为了估计工业机器人高速运动引起的动载荷和路径偏差,要进行路径控制仿真和动态模型的仿真。这些都必须以工业机器人动力学模型为基础。 工业机器人是一个非线性的复杂的动力学系统。动力学问题的求解比较困难,而且需要较长的运算时间。因此,简化求解过程,最大限度地减少工业机器人动力学在线计算的时间是一个受到关注的研究课题。 在这一章里,我们将首先讨论与工业机器人速度和静力学有关的雅可比矩阵,然后介绍工业机器人的静力学问题和动力学问题。

机器人系统常用仿真软件介绍

1 主要介绍以下七种仿真平台(侧重移动机器人仿真而非机械臂等工业机器人仿真): 1.1 USARSim-Unified System for Automation and Robot Simulation USARSim是一个基于虚拟竞技场引擎设计高保真多机器人环境仿真平台。主要针对地面机器人,可以被用于研究和教学,除此之外,USARSim是RoboCup救援虚拟机器人竞赛和虚拟制造自动化竞赛的基础平台。使用开放动力学引擎ODE(Open Dynamics Engine),支持三维的渲染和物理模拟,较高可配置性和可扩展性,与Player兼容,采用分层控制系统,开放接口结构模拟功能和工具框架模块。机器人控制可以通过虚拟脚本编程或网络连接使用UDP协议实现。被广泛应用于机器人仿真、训练军队新兵、消防及搜寻和营救任务的研究。机器人和环境可以通过第三方软件进行生成。软件遵循免费GPL条款,多平台支持可以安装并运行在Linux、Windows和MacOS操作系统上。 1.2 Simbad Simbad是基于Java3D的用于科研和教育目的多机器人仿真平台。主要专注于研究人员和编程人员热衷的多机器人系统中人工智能、机器学习和更多通用的人工智能算法一些简单的基本问题。它拥有可编程机器人控制器,可定制环境和自定义配置传感器模块等功能,采用3D虚拟传感技术,支持单或多机器人仿真,提供神经网络和进化算法等工具箱。软件开发容易,开源,基于GNU协议,不支持物理计算,可以运行在任何支持包含Java3D库的Java客户端系统上。 1.3 Webots Webots是一个具备建模、编程和仿真移动机器人开发平台,主要用于地面机器人仿真。用户可以在一个共享的环境中设计多种复杂的异构机器人,可以自定义环境大小,环境中所有物体的属性包括形状、颜色、文字、质量、功能等也都可由用户来进行自由配置,它使用ODE检测物体碰撞和模拟刚性结构的动力学特性,可以精确的模拟物体速度、惯性和摩擦力等物理属性。每个机器人可以装配大量可供选择的仿真传感器和驱动器,机器人的控制器可以通过内部集成化开发环境或者第三方开发环境进行编程,控制器程序可以用C,C++等编写,机器人每个行为都可以在真实世界中测试。支持大量机器人模型如khepera、pioneer2、aibo等,也可以导入自己定义的机器人。全球有超过750个高校和研究中心使用该仿真软件,但需要付费,支持各主流操作系统包括Linux, Windows和MacOS。 1.4 MRDS-Microsoft Robotics Developer Studio MRDS是微软开发的一款基于Windows环境、网络化、基于服务框架结构的机器人控制仿真平台,使用PhysX物理引擎,是目前保真度最高的仿真引擎之一,主要针对学术、爱好者和商业开发,支持大量的机器人软硬件。MRDS是基于实时并发协调同步CCR(Concurrency and Coordination Runtime)和分布式软件服务DSS(Decentralized Software Services),进行异步并行任务管理并允许多种服务协调管理获得复杂的行为,提供可视化编程语言(VPL)和可视化仿真环境(VSE)。支持主流的商业机器人,主要编程语言为C#,非商业应用免费,但只支持在Windows操作系统下进行开发。 1.5 PSG-Player/Stage/Gazebo

简单串联机器人ADAMS仿真

机械系统动力学 简化串联机器人的运动学与动力学仿真分析 学院:机械工程学院 专业:机械设计制造 及其自动化 学生姓名: 学号: 指导教师: 完成日期: 2015.01.09

摘要 在机器人研究中,串联机器人研究得较为成熟,其具有结构简单、成本低、控制简单、运动空间大等优点,已成功应用于很多领域。本文在ADAMS 中用连杆模拟两自由度的串联机器人(机械臂),对其分别进行运动学分析、动力学分析。得出该机构在给出工作条件下的位移、速度、加速度曲线和关节末端的运动轨迹。 关键词:机器人;ADAMS;曲线;轨迹 一、ADAMS软件简介 ADAMS,即机械系统动力学自动分析(Automatic Dynamic Analysis of Mechanical Systems),该软件是美国MDI公司(Mechanical Dynamics Inc.) (现已并入美国MSC公司)开发的虚拟样机分析软件。目前,ADAMS已经被全世界各行各业的数百家主要制造商采用。ADAMS软件使用交互式图形环境和零件库、约束库、力库,创建完全参数化的机械系统几何模型,其求解器采用多刚体系统动力学理论中的拉格朗日方程方法,建立系统动力学方程,对虚拟机械系统进行静力学、运动学和动力学分析,输出位移、速度、加速度和反作用力曲线。ADAMS软件的仿真可用于预测机械系统的性能、运动范围、碰撞检测、峰值载荷以及计算有限元的输入载荷等。 二、简化串联机器人的运动学仿真 (1)启动ADAMS/View。 在欢迎对话框中选择新建模型,模型取名为robot,并将单位设置为MMKS,然后单击OK。 (2)打开坐标系窗口。 按下F4键,或者单击菜单【View】→【Coordinate Window】后,打开坐标系窗口。当鼠标在图形区移动时,在坐标窗口中显示了当前鼠标所在位置的坐标值。

机器人机械臂运动学分析(仅供借鉴)

平面二自由度机械臂动力学分析 [摘要] 机器臂是一个非线性的复杂动力学系统。动力学问题的求解比较困难,而且需要较长的运算时间,因此,这里主要对平面二自由度机械臂进行动力学研究。本文采用拉格朗日方程在多刚体系统动力学的应用方法分析平面二自由度机械臂的正向动力学。经过研究得出平面二自由度机械臂的动力学方程,为后续更深入研究做铺垫。 [关键字] 平面二自由度 一、介绍 机器人是一个非线性的复杂动力学系统。动力学问题的求解比较困难,而且需要较长的运算时间,因此,简化解的过程,最大限度地减少工业机器人动力学在线计算的时间是一个受到关注的研究课题。 机器人动力学问题有两类: (1) 给出已知的轨迹点上的,即机器人关节位置、速度和加速度,求相应的关节力矩向量Q r。这对实现机器人动态控制是相当有用的。 (2) 已知关节驱动力矩,求机器人系统相应的各瞬时的运动。也就是说,给出关节力矩向量τ,求机器人所产生的运动。这对模拟机器人的运动是非常有用的。 二、二自由度机器臂动力学方程的推导过程 机器人是结构复杂的连杆系统,一般采用齐次变换的方法,用拉格朗日方程建立其系统动力学方程,对其位姿和运动状态进行描述。机器人动力学方程的具体推导过程如下: (1) 选取坐标系,选定完全而且独立的广义关节变量θr ,r=1, 2,…, n。 (2) 选定相应关节上的广义力F r:当θr是位移变量时,F r为力;当θr是角度变量时, F r为力矩。 (3) 求出机器人各构件的动能和势能,构造拉格朗日函数。 (4) 代入拉格朗日方程求得机器人系统的动力学方程。 下面以图1所示说明机器人二自由度机械臂动力学方程的推导过程。

机器人动力学汇总

机器人动力学研究的典型方法和应用 (燕山大学 机械工程学院) 摘 要:本文介绍了动力学分析的基础知识,总结了机器人动力学分析过程中比较常用的动力学分析的方法:牛顿—欧拉法、拉格朗日法、凯恩法、虚功原理法、微分几何原理法、旋量对偶数法、高斯方法等,并且介绍了各个方法的特点。并通过对PTl300型码垛机器人弹簧平衡机构动力学方法研究,详细分析了各个研究方法的优越性和方法的选择。 前 言:机器人动力学的目的是多方面的。机器人动力学主要是研究机器人机构的动力学。机器人机构包括机械结构和驱动装置,它是机器人的本体,也是机器人实现各种功能运动和操作任务的执行机构,同时也是机器人系统中被控制的对象。目前用计算机辅助方法建立和求解机器人机构的动力学模型是研究机器人动力学的主要方法。动力学研究的主要途径是建立和求解机器人的动力学模型。所谓动力学模指的是一组动力学方程(运动微分方程),把这样的模型作为研究力学和模拟运动的有效工具。 报告正文: (1)机器人动力学研究的方法 1)牛顿—欧拉法 应用牛顿—欧拉法来建立机器人机构的动力学方程,是指对质心的运动和转动分别用牛顿方程和欧拉方程。把机器人每个连杆(或称构件)看做一个刚体。如果已知连杆的表征质量分布和质心位置的惯量张量,那么,为了使连杆运动,必须使其加速或减速,这时所需的力和力矩是期望加速度和连杆质量及其分布的函数。牛顿—欧拉方程就表明力、力矩、惯性和加速度之间的相互关系。 若刚体的质量为m ,为使质心得到加速度a 所必须的作用在质心的力为F ,则按牛顿方程有:ma F = 为使刚体得到角速度ω、角加速度εω= 的转动,必须在刚体上作用一力矩M , 则按欧拉方程有:εωI I M += 式中,F 、a 、M 、ω、ε都是三维矢量;I 为刚体相对于原点通过质心并与刚

二自由度机器人的位置控制

实验二自由度机器人的位置控制 一、实验目的 1. 运用Matlab语言、Simulink及Robot工具箱,搭建二自由度机器人的几何模 型、动力学模型, 2. 构建控制器的模型,通过调整控制器参数,对二自由度机器人的位姿进行控 制,并达到较好控制效果。 二、工具软件 1.Matlab软件 2.Simulink动态仿真环境 3.robot工具箱 模型可以和实际中一样,有自己的质量、质心、长度以及转动惯量等,但需要注意的是它所描述的模型是理想的模型,即质量均匀。这个工具箱还支持Simulink的功能,因此,可以根据需要建立流程图,这样就可以使仿真比较明了。 把robot 工具箱拷贝到MATLAB/toolbox文件夹后,打开matalb软件,点击file--set path,在打开的对话框中选add with subfolders,选中添加MATLAB/toolbox/robot,保存。这是在matlab命令窗口键入roblocks就会弹出robot 工具箱中的模块(如下图)。

三、实验原理 在本次仿真实验中,主要任务是实现对二自由度机器人的控制,那么首先就要创建二自由度机器人对象, 二自由度机器人坐标配置 仿真参数如下表1: 表1 二连杆参数配置

1.运动学模型构建二连杆的运动学模型,搭建twolink模型在MATLAB命令窗口下用函数drivebot(WJB)即可观察到该二连杆的动态位姿图。 %文件名命名为自己名字的首字母_twolink %构造连杆一 L{1}=link([0 0.45 0 0 0],'standard') ; L{1}.m=23.9 ;

一种自行车机器人动力学分析和仿真

一种自行车机器人的动力学分析与仿真 邹俊 (北京邮电大学自动化学院,北京100876) 摘要:自行车是一种高效而且环保的交通工具。但自行车动力学特征较为复杂,从控制学角度说,其本身就是一个欠驱动的不稳定系统。行驶中的自行车的动力学模型相对复杂,受外界因素干扰很大,如不同的地面情况和风速的影响,很难完全模拟。因此,自行车的自动控制的发展是一项具有挑战意义的主题。本文提出了一种自行车机器人的建模方法并设计了车把控制器,并用仿真实验验证了其正确性。 关键词:自行车机器人;自动控制;稳定性 中国图书分类号:TP273.5 Modeling and Simulation of Autonomous Bicycle Abstract: Bicycle is an efficient and environment-friendly transport. However, the dynamics of bicycle is complicated. From the control point of view, it is an under actuated nonholonomic system. The dynamics of bicycle is relatively complicated, and very susceptible to disturbance from outside, such as different ground conditions and wind speed, and it is difficult to fully simulate. Thus, the development of automatic control for driving a bicycle is a challenging theme. This paper presents a dynamic model of bicycle and designs a steer controller. Simulation is performed to prove the validity of this controller. Key words: Autonomous Bicycle; Automatic Control; Stability 0引言 自行车是一种高效而且环保的交通工具。自从1818年,德国人德莱斯(Baron Karivon Drais)在法国巴黎发明了带车把的木制两轮自行车以来,自行车给人类的生活带来了极大的便利,同时,人们也在对其进行不断的改进[1][2]。2006年,日本著名的机器人“村田顽童”更是向人们展示了行走坡道和S型平衡木、倒车行走,检测障碍物,进入车库,手机遥控操作,发声、播放音乐等功能。到目前为止,自行车机器人已经取得一定的研究成果,其研究内容主要围绕动力学建模和提出新的控制算法两方面内容展开的。 自行车与倒立摆有很大的相似性,然而前者动力学特性更加复杂,可以利用模糊神经网络控制、非线性控制等控制方法来建模和设计控制器。同时,自行车机器人还涉及到传感器技术、自适应控制、机械力学、无线通信等众多学科。因此,无论在理论和实践中都具有十分重要的意义。 1动力学分析及建模

空间二连杆机器人的动力学建模及其动态过程仿真

空间二连杆机器人的动力学建 模 及其动态过程仿真 作者:td 一引言 1.机器人机械臂的运动学与动力学分析方法 目录 空间二连杆机器人的动力学建模 (1) 及其动态过程仿真 (1) 作者:td (1) 一引言 (1) 1.1用户界面模块(ADAMS/View) (4) 1.2求解器模块(ADAMS/Solver) (5) 1.3后处理模块(ADAMS/PostProcessor) (6) 二.空间二连杆机器人adams建模仿真 (6) 2.1空间二连杆串联机器人 (6) 在ADAMS中用长方形连杆模拟机械臂,对两自由度的机械臂分别进行运动学分析动力学分析。 (6) 2.1.1运动学分析 (6) 2.1.2运动学分析 (9)

机器人的运动学和动力学既包含有一般机械的运动学、动力学内容,又反映了机器人的独特内容。工业机器人的运动学主要讨论了运动学的正问题和逆问题。假设一个构型已知的机器人,即它的所有连杆长度和关节角度()1q t ,()2q t ,()3q t …()n q t ,…都是已知的,其中n 为自由度数,那么计算机器人末端执行器相对于参考坐标系的位姿就称为运动学的正问题分析。换言之,如果已知机器人所有的关节变量,用正运动学方程就能计算任一瞬间机器人的位姿。然而,如果希望机器人的末端执行器到达一个期望的位姿,就必须要知道机器人操作臂每一个连杆的几何参数和所有关节的角矢量()12,,T n q q q q =???利用操作臂连杆几何参数和末端执行器期望的位姿来求解关节角矢量是运动学逆问题。运动学正问题可以利用齐次变换法来求解。设i 杆坐标系相对于基座坐标系的位姿齐次变换矩阵是b i T ,则 1231b i n n T A A A A A -=?????? ()11- 式中i A 为i 杆坐标系相对于1i -杆坐标系的坐标变换矩阵。相对于正运动学方程,机器人逆运动学方程显得更为重要。由于按给定末端执行器的位姿求解关节变量是在关节空间中进行非线性方程的求解,其中涉及多值性和奇异现象,因此,这一逆问题成为机器人运动学中的一个重要内容。机器人的控制器将用这些方程来计算关节值,并以此来运行机器人到达期望的位姿。机器人逆问题可有多种解法,如逆变换法、旋量代数法、数值迭代法、几何法等,其中Jaeobian 矩阵的速算法占有重要的地位。机器人作为多自由度可编程的工作系统,在运动学中研究的内容还有末端操作器运动规划、工作空间确定、位姿精度分析与补偿等。目前,对于一般机器人运动学的逆问题大部分都得到了解决,但是,对于有任意结构和有冗余自由度机器人的运动学逆问题,研究得还不够充分。 机器人操作臂的动力学建模主要是研究各主动关节的驱动力与操作臂运动的关系。机器人操作臂是一个十分复杂的动力学系统。机器人动力学方程的非线性特点和强耦合性使得对它的研究十分困难和复杂。目前人们已经提出了许多种动力学建模方法,分别基于不同的力学方程和原理。C .T .Lin ,Calafiore 等对Newton —Euler 动力学建模方法和Lagrange 方法在简化递推过程及减少运算次数上做了不少有益的工作;有些学者从计算机符号代数方向推导并行算法来进行研究;T .R .Kane 等发展了利用偏速度和广义力建模的Kane 方程法;有些学者利用广义d ’Alembert 原理来进行建模;还有人研究用图论进行机器人动力学分析的方法。其中以Newton —Euler 动力学建模方法及d ’Alembert 建模方法(或以这两种方法为基础)应用最为普遍。Newton —Euler 方法具有递推的形式,非常适合于数值计算,与

相关文档
最新文档