• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• FewShotLearning-master
  • datasets
    • data-loader.py
    • miniImagenet.py
    • __init__.py
  • utils
    • util.py
    • create_miniImagenet.py
    • __init__.py
  • LICENSE
  • option.py
  • config
    • 5-shot-5-class.py
    • lstm
      • train-imagenet-1shot.py
      • test-lstm.py
      • train-imagenet-5shot.py
      • __init__.py
    • baselines
      • train-conv-nearest-neighbor.py
      • train-pre-trained-SGD.py
      • train-matching-net.py
      • __init__.py
      • train-pixel-nearest-neighbor.py
      • test-conv-nearest-neighbor.py
      • test-matching-net.py
    • __init__.py
    • imagenet.py
    • 1-shot-5-class.py
  • visualize
    • __init__.py
    • visualize.py
  • logger.py
  • main.py
  • README.md
  • model
    • lstm-classifier.py
    • lstm
      • lstmhelper.py
      • metaLearner.py
      • metalstm.py
      • train-lstm.py
      • __init__.py
      • recurrentLSTMNetwork.py
      • learner.py
      • bnlstm.py
    • baselines
      • matching-net.py
      • fce-embedding.py
      • simple-embedding.py
      • __init__.py
    • __init__.py
    • matching-net-classifier.py
  • .gitignore

import torch
from torch import nn
from torch.autograd import Variable

P = Variable(torch.FloatTensor(1).fill_(10))
expP = Variable(torch.exp(P.data))
negExpP = Variable(torch.exp(-P.data))

def preProc1(x):
    # Access the global variables
    global P,expP,negExpP
    P = P.type_as(x)
    expP = expP.type_as(x)
    negExpP = negExpP.type_as(x)

    # Create a variable filled with -1. Second part of the condition
    z = Variable(torch.zeros(x.size()).fill_(-1)).type_as(x)
    absX = torch.abs(x)
    cond1 = torch.gt(absX, negExpP)
    if (torch.sum(cond1) > 0).data.all():
        x1 = torch.log(torch.abs(x[cond1]))/P
        z[cond1] = x1
    return z

def preProc2(x):
    # Access the global variables
    global P, expP, negExpP
    P = P.type_as(x)
    expP = expP.type_as(x)
    negExpP = negExpP.type_as(x)

    # Create a variable filled with -1. Second part of the condition
    z = Variable(torch.zeros(x.size())).type_as(x)
    absX = torch.abs(x)
    cond1 = torch.gt(absX, negExpP)
    cond2 = torch.le(absX, negExpP)
    if (torch.sum(cond1) > 0).data.all():
        x1 = torch.sign(x[cond1])
        z[cond1] = x1
    if (torch.sum(cond2) > 0).data.all():
        x2 = x[cond2]*expP
        z[cond2] = x2
    return z

def preprocess(grad,loss):

    #preGrad = Variable(grad.data.new(grad.data.size()[0], 1, 2).zero_())
    #preGrad = grad.expand(grad.data.size()[0], 1, 2)
    preGrad = grad.clone().expand(grad.data.size()[0], 1, 2)
    preGrad[:, :, 0] = preProc1(grad)
    preGrad[:, :, 1] = preProc2(grad)

    #lossT = Variable(loss.data.new(1,1,1).zero_())
    #lossT[0] = loss
    #preLoss = Variable(loss.data.new(1,1,2).zero_())
    #preLoss = loss.expand(1, 1, 2)
    preLoss = loss.clone().expand(1, 1, 2)
    preLoss[:, :, 0] = preProc1(loss)
    preLoss[:, :, 1] = preProc2(loss)
    return preGrad,preLoss