def __init__(self,string1,string2):
     self.string1=str(string1)
     self.string2=str(string2)
     a=len(self.string1)+1
     b=len(self.string2)+1
     self.matrix=np.zeros([a,b],dtype=int)
     for i in np.arange(len(self.string2)+1):
        self.matrix[0,i]=i
     for j in np.arange(len(self.string1)+1):
        self.matrix[j,0]=j
 def edit_distance(self):
    for i in np.arange(1,len(self.string1)+1):
        for j in np.arange(1,len(self.string2)+1):
            if self.string1[i-1]==self.string2[j-1]:
                self.matrix[i,j]=self.matrix[i-1,j-1]
            else:
                deletion = self.matrix[i-1,j] + 1
                insertion = self.matrix[i,j-1] + 1
                substitution =self.matrix[i-1,j-1] +1
                self.matrix[i,j]=min(deletion,insertion,substitution)
    print(self.matrix)
Exemple #3
0
def curve(c, offset):
    if c <= 0:
        return None
    if c <= 1:
        (a, b) = dom(c)
        (a1, b1) = (a + offset, b + offset)
        cur = []
        for x in np.arange(a1, b1, .1):
            cur.append((x, lsy(x, c)))
        for x in np.arange(b1, a1, -.1):
            cur.append((x, -lsy(x, c)))
        return cur
    else:
        return [(x, lsy(x, c) * offset) for x in np.linspace(-3, 3, 15)]
Exemple #4
0
def fetch_pids_ttol(pnts: MatrixVector, psys: PanelSystem, ztol: float=0.01, ttol: float=0.1):
    shp = pnts.shape
    pnts = pnts.reshape((-1, 1))
    numpnt = pnts.shape[0]
    numpnl = len(psys.pnls)
    pidm = zeros((1, numpnl), dtype=int)
    wintm = zeros((numpnt, numpnl), dtype=bool)
    abszm = zeros((numpnt, numpnl), dtype=float)
    for pnl in psys.pnls.values():
        pidm[0, pnl.ind] = pnl.pid
        wintm[:, pnl.ind], abszm[:, pnl.ind] = pnl.within_and_absz_ttol(pnts[:, 0], ttol=ttol)
    abszm[wintm is False] = float('inf')
    minm = argmin(abszm, axis=1)
    minm = array(minm).flatten()
    pidm = array(pidm).flatten()
    pids = pidm[minm]
    pids = matrix([pids], dtype=int).transpose()
    indp = arange(numpnt)
    minz = array(abszm[indp, minm]).flatten()
    minz = matrix([minz], dtype=float).transpose()
    chkz = minz < ztol
    pids[logical_not(chkz)] = 0
    pids = pids.reshape(shp)
    chkz = chkz.reshape(shp)
    return pids, chkz
 def initialization(self):
     self.Weights = []
     self.Weights.append(np.random.randn(self.inputs, self.hiddenNodes[0]))
     for i in arange(self.hiddenLayers - 1) + 1:
         self.Weights.append(
             np.random.randn(self.hiddenNodes[i - 1], self.hiddenNodes[i]))
     self.Weights.append(np.random.randn(self.hiddenNodes[-1],
                                         self.outputs))
 def sim(self,Xi):
     H = []
     N = []
     import ipdb; ipdb.set_trace()
     N.append(np.dot(Xi,self.Weights[0]))
     H.append(tanh(N[0]))
     for i in arange(self.hiddenLayers-1)+1:
         N.append(np.dot(H[i-1],self.Weights[i]))
         H.append(tanh(N[i]))
     N.append(np.dot(H[-1],self.Weights[-1]))
     Out = np.dot(H[-1],self.Weights[-1])
     return Out,H,N
 def sim(self, Xi):
     H = []
     N = []
     import ipdb
     ipdb.set_trace()
     N.append(np.dot(Xi, self.Weights[0]))
     H.append(tanh(N[0]))
     for i in arange(self.hiddenLayers - 1) + 1:
         N.append(np.dot(H[i - 1], self.Weights[i]))
         H.append(tanh(N[i]))
     N.append(np.dot(H[-1], self.Weights[-1]))
     Out = np.dot(H[-1], self.Weights[-1])
     return Out, H, N
Exemple #8
0
 def train(self, data, training):
     'En esta funcion se realiza 10-Fold CV para entrenar la red con una expansion de entre 20-75%.'
     'El algoritmo de entrenamiento es Descenso por Gradiente Estocastico o Extreme Learning Machine.'
     # 10-Fold Cross Validation
     folds = 10; iters = 10;
     kf = KFold(data.shape[0], n_folds=folds)
     hiddenNodes = arange(2*data.shape[1])+1
     Error_HNodes = []
     Nets_HNodes = []
     for j in hiddenNodes:
         self.setHiddenNodes([j])
         Mean_error_iter = []
         Mean_nets_iter = []
         for train_index, val_index in kf:
             X, Xval = data[train_index], data[val_index]
             Error_iter = []
             Nets_iter = []
             for i in np.arange(iters):
                 self.initialization() # Inicializaciones comunes
                 if training == 'elm':
                     Out,H,N = self.sim(X)
                     H = H[-1]
                     pseudoinverse = pinv(H)
                     beta = np.dot(pseudoinverse,X)
                     self.Weights[-1] = beta
                     # Validation
                     Out_val,H_val,N_val = self.sim(Xval)
                     # Se guarda el error y la red
                     MSE = [mean_squared_error(Xval,Out_val)]
                     Networks = [self.Weights]
                 Error_iter.append(np.min(MSE))
                 Nets_iter.append(Networks[np.argmin(MSE)])
             Mean_error_iter.append(np.mean(Error_iter))
             Mean_nets_iter.append(Nets_iter[np.argmin(Error_iter)])
         Error_HNodes.append(np.mean(Mean_error_iter))
         Nets_HNodes.append(Mean_nets_iter[np.argmin(Mean_error_iter)])
     self.Weights = Nets_HNodes[np.argmin(Error_HNodes)]
     Final_Error = np.min(Error_HNodes)
     selected_Nodes = hiddenNodes[np.argmin(Error_HNodes)]
     self.setHiddenNodes([selected_Nodes])
     return Final_Error
Exemple #9
0
CZ_LOBS = config.getLobsConfig()["lobs"]["CZ"]
# CZ_LOBS = ["SMS", "GSM", "MMS","SMG","ATS","OTA"]


data = []
lobsNameList = []
for lob in CZ_LOBS:
  data.append(lobData(lob))
  lobsNameList.append(lob)

R = corrcoef(data)
print(R)
plt.pcolor(R)
plt.colorbar()
plt.yticks(arange(0.5, len(CZ_LOBS) + 0.5), CZ_LOBS)
plt.xticks(arange(0.5, len(CZ_LOBS) + 0.5), CZ_LOBS)
#plt.show()


def dendo():
  from matplotlib import pyplot as plt
  from scipy.cluster.hierarchy import dendrogram, linkage
  import numpy as np

  np.random.seed(4711)  # for repeatability of this tutorial
  a = np.random.multivariate_normal([10, 0], [[3, 1], [1, 4]], size=[100, ])
  b = np.random.multivariate_normal([0, 20], [[3, 1], [1, 4]], size=[50, ])
  X = R
  Z = linkage(X, 'ward')
  plt.figure(figsize=(25, 10))
Exemple #10
0
        return pt
    return showPair(pt)


glops = ""


def drawPoint(pt, options=None):
    if options is None:
        options = glops
    return "\\node[{}] at {} {{}}; ".format(options, showPt(pt))


def drawPath(pt, options=None):
    if options is None:
        options = glops
    return "\\draw[{}] {};".format(options, "--".join(map(showPt, pt)))


glops = "red,->"

for x in [.5, 1.5, 2.5]:
    for y in np.arange(-3, 4):
        print(
            drawPath([(x, y + x * .1 - .1), (3.2, y + x * .1 - .1)],
                     "red,->, thick"))
        #print(drawPoint((x,y+x*.1-.1), "atom"))
        print(
            drawPath([(-3.2, y - x * .1 + .1), (-x, y - x * .1 + .1)],
                     "blue,->, thick"))
        #print(drawPoint((-x,y-x*.1+.1), "atom"))
 def initialization(self):
     self.Weights = []
     self.Weights.append(np.random.randn(self.inputs,self.hiddenNodes[0]))
     for i in arange(self.hiddenLayers-1)+1:
         self.Weights.append(np.random.randn(self.hiddenNodes[i-1],self.hiddenNodes[i]))
     self.Weights.append(np.random.randn(self.hiddenNodes[-1],self.outputs))
Exemple #12
0
        return pt
    return showPair(pt)


glops = ""


def drawNode(points, options=None):
    if options is None:
        options = glops
    return "\\draw[{}] {}; ".format(options, "--".join(map(showPt, points)))


def drawPoint(pt, options=None):
    if options is None:
        options = glops
    return "\\node[{}] at {} {{}}; ".format(options, showPt(pt))


glops = "atom"


def p(r, theta):
    return (r * math.cos(theta), r * math.sin(theta))


for r in np.arange(.5, 6, .5):
    for theta in np.arange(0, 2 * math.pi, .5 * math.pi / (r**3)):
        (x, y) = p(r, theta)
        if -3 < x < 3 and -3 < y < 3:
            print(drawPoint((x, y)))