質問編集履歴

1 ソースコードの追加

gab76

gab76 score 0

2018/07/13 16:22  投稿

No module named models.Alexというエラーについて
### 前提・実現したいこと
下記のサイト
https://qiita.com/ohnabe/items/dc915c06ef37a2d30799
を参考にして、adversarial examplesの実行を試みておりますが、
No module named models.Alexというエラーに遭い、行き詰まってしまいました。
当方、python超初心者ですが、解決法をご教授いただけたらと思います。
### 発生している問題・エラーメッセージ
```
 File "create_as.py", line 9, in <module>
   import models.Alex
ImportError: No module named models.Alex
```
### ソースコード  
```python  
#!/usr/bin/env python  
# -*- coding: utf-8 -*-  
 
import numpy as np  
import chainer  
import chainer.functions as F  
from chainer.links.caffe import CaffeFunction  
import pickle  
import models.Alex  
from PIL import Image  
 
from adv_models.fast_gradient import fast_gradient  
from adv_models.iterative_gradient import iterative_gradient  
from adv_models.iterative_least_likely import iterative_least_likely  
 
 
IMAGENET_MEAN_FILE = "../data/ilsvrc_2012_mean.npy"  
INPUT_IMAGE_SIZE = 227  
 
def load_caffemodel(model_path):  
   caffe_model = CaffeFunction(model_path)  
   return caffe_model  
 
 
def save_models(caffe_model, save_model_path):  
   with open(save_model_path, 'wb') as f:  
       pickle.dump(caffe_model, f)  
 
 
def load_models(save_model_path):  
   with open(save_model_path, 'rb') as f:  
       model = pickle.load(f)  
       return model  
 
 
def copy_model(src, dst):  
   assert isinstance(src, chainer.Chain)  
   assert isinstance(dst, chainer.Chain)  
   for child in src.children():  
       if child.name not in dst.__dict__: continue  
       dst_child = dst[child.name]  
       if type(child) != type(dst_child): continue  
       if isinstance(child, chainer.Chain):  
           copy_model(child, dst_child)  
       if isinstance(child, chainer.Link):  
           match = True  
           for a, b in zip(child.namedparams(), dst_child.namedparams()):  
               if a[0] != b[0]:  
                   match = False  
                   break  
               if a[1].data.shape != b[1].data.shape:  
                   match = False  
                   break  
           if not match:  
               print('Ignore %s because of parameter mismatch' % child.name)  
               continue  
           for a, b in zip(child.namedparams(), dst_child.namedparams()):  
               b[1].data = a[1].data  
           print('Copy %s' % child.name)  
 
 
def create_mean_image_array(pic_mean_data_path, size_image):  
   mean_data = np.load(pic_mean_data_path)  
   mean_data = Image.fromarray(mean_data.astype(np.uint8), 'RGB').resize((size_image, size_image))  
   mean_data = np.asarray(mean_data).astype(np.float32)  
   return mean_data  
 
 
def substract_mean_image(target_array, mean_array):  
   # mean_value: 104 B  
   # mean_value: 117 G  
   # mean_value: 123 R  
   result_array = target_array - mean_array  
   return result_array  
 
 
def add_mean_image(target_array, mean_array):  
   result_array = target_array + mean_array  
   return result_array  
 
 
def resize_image(original_image_path):  
   img = Image.open(original_image_path)  
   print("original image format:{} {}".format(img.size, img.mode))  
 
   img_resize = img.resize((INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE))  
   print("resize image format:{} {}".format(img_resize.size, img_resize.mode))  
   return img_resize  
 
 
def format2chainer(img_data):  
   # RGB to GBR  
   arrayImg = np.asarray(img_data).astype(np.float32)[:, :, ::-1]  
   # HWC to CWH  
   arrayImg = arrayImg.transpose(2, 0, 1)  
   # 3-dimensions to 4-dimensions  
   arrayImg = arrayImg.reshape((1,) + arrayImg.shape)  
   return arrayImg  
 
 
def format2orig(chainer_img):  
   # CWH to HWC  
   #orig_image = chainer_img.transpose(1, 2, 0).astype(np.uint8)  
   orig_image = chainer_img.transpose(1, 2, 0)  
   # BGR to RGB  
   orig_image = orig_image[:,:,::-1]  
   return orig_image  
 
 
def create_label_list(label_file_path):  
   label_d = {}  
   with open(label_file_path, "r") as f:  
       for line in f:  
           line = line.rstrip("\n").strip(" ").split(":")  
           if len(line) == 2:  
              label_d[int(line[0])] = line[1].strip(" ")  
   return label_d  
 
 
def get_result(predict_result, label_d):  
   prob = np.max(predict_result)  
   label_ind = np.argmax(predict_result)  
   label = label_d[label_ind]  
   return prob, label_ind, label  
 
 
if __name__ == '__main__':  
   #model = load_caffemodel("models/bvlc_alexnet.caffemodel")  
   #save_models(model, "models/alexnet.chainermodel")  
 
   caffe_model = load_models("../models/alexnet.chainermodel")  
   chainer_model = models.Alex.Alex()  
 
   # get label dict  
   label_d = create_label_list("../data/imagenet_label.txt")  
 
   # copy caffe_model W, b to chainer_model  
   copy_model(caffe_model, chainer_model)  
 
   # create mean image array  
   mean_image_array = create_mean_image_array(IMAGENET_MEAN_FILE, INPUT_IMAGE_SIZE)  
 
   # predict target_image  
   orig_img = resize_image("../data/panda2.jpeg")  
   orig_img.show()  
 
   orig_array = np.asarray(orig_img)  
   orig_array = substract_mean_image(orig_array, mean_image_array)  
 
   chainer_array = format2chainer(orig_array)  
 
   # apply gradient sign method  
   #adv_array, adv_part_array, orig_result = fast_gradient(chainer_model, chainer_array, eps=8.0)  
 
   # apply iterative gradient sign method  
   #adv_array, adv_part_array, orig_result = iterative_gradient(chainer_model, chainer_array,  
   #                                                                   eps=8.0, alpha=1.0)  
 
   # apply iterative least likely class method  
   adv_array, adv_part_array, orig_result = iterative_least_likely(chainer_model, chainer_array,  
                                                                   eps=8.0, alpha=1.0)  
   least_ind = np.argmin(orig_result)  
   print("least likely category {}".format(label_d[least_ind]))  
 
   # predict original image_result  
   orig_prob, orig_ind, orig_label = get_result(orig_result, label_d)  
   print("predict_original_image: {} predict_prob: {}".format(orig_label.strip(" "), orig_prob))  
 
   # predict adversarial_image  
   predict_result = F.softmax(chainer_model(adv_part_array)).data  
   part_prob, part_label_ind, part_label = get_result(predict_result, label_d)  
   print("predict_adversarial_perturbations: {} predict_prob: {}".format(part_label, part_prob))  
 
   predict_result = F.softmax(chainer_model(adv_array)).data  
   adv_prob, adv_label_ind, adv_label = get_result(predict_result, label_d)  
   print("predict_adversarial_examples: {} predict_prob: {}".format(adv_label, adv_prob))  
   print("original category prob with adv_images {}".format(predict_result[0][orig_ind]))  
 
   # show adv_image  
   adv_array = format2orig(adv_array[0])  
   adv_part_array = format2orig(adv_part_array[0])  
   adv_array = add_mean_image(adv_array, mean_image_array)  
   adv_array = np.clip(adv_array, 0, 255)  
   adv_array = adv_array.astype(np.uint8)  
   Image.fromarray(adv_array, 'RGB').show()  
   Image.fromarray(adv_part_array, 'RGB').show()  
```  
 
 
### 補足情報(FW/ツールのバージョンなど)
開発環境
macOS High Sierra 10.13.1
python 2.7.10
chainer 4.2.0
  • Python

    12175 questions

    Pythonは、コードの読みやすさが特徴的なプログラミング言語の1つです。 強い型付け、動的型付けに対応しており、後方互換性がないバージョン2系とバージョン3系が使用されています。 商用製品の開発にも無料で使用でき、OSだけでなく仮想環境にも対応。Unicodeによる文字列操作をサポートしているため、日本語処理も標準で可能です。

  • Chainer

    209 questions

    Chainerは、国産の深層学習フレームワークです。あらゆるニューラルネットワークをPythonで柔軟に書くことができ、学習させることが可能。GPUをサポートしており、複数のGPUを用いた学習も直感的に記述できます。

思考するエンジニアのためのQ&Aサイト「teratail」について詳しく知る