python install

python/paddle/__init__.py

@@ -12,9 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import os
-from paddle.check_import_scipy import check_import_scipy
-
-check_import_scipy(os.name)
 
 try:
     from paddle.version import full_version as __version__

python/paddle/check_import_scipy.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-def check_import_scipy(OsName):
-    print_info = ""
-    if OsName == 'nt':
-        try:
-            import scipy.io as scio
-        except ImportError as e:
-            print_info = str(e)
-        if (len(print_info) > 0):
-            if 'DLL load failed' in print_info:
-                raise ImportError(
-                    print_info +
-                    "\nplease download visual C++ Redistributable for vs 2015, https://www.microsoft.com/en-us/download/details.aspx?id=48145"
-                )
-    return

python/paddle/dataset/__init__.py

@@ -22,10 +22,8 @@ import paddle.dataset.cifar
 import paddle.dataset.movielens
 import paddle.dataset.conll05
 import paddle.dataset.uci_housing
-import paddle.dataset.sentiment
 import paddle.dataset.wmt14
 import paddle.dataset.wmt16
-import paddle.dataset.mq2007
 import paddle.dataset.flowers
 import paddle.dataset.voc2012
 import paddle.dataset.image
@@ -37,11 +35,9 @@ __all__ = [
     'cifar',
     'movielens',
     'conll05',
-    'sentiment',
     'uci_housing',
     'wmt14',
     'wmt16',
-    'mq2007',
     'flowers',
     'voc2012',
     'image',

python/paddle/dataset/mq2007.py

-# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-MQ2007 dataset
-
-MQ2007 is a query set from Million Query track of TREC 2007. There are about 1700 queries in it with labeled documents. In MQ2007, the 5-fold cross
-validation strategy is adopted and the 5-fold partitions are included in the package. In each fold, there are three subsets for learning: training set,
-validation set and testing set.
-
-MQ2007 dataset from website
-http://research.microsoft.com/en-us/um/beijing/projects/letor/LETOR4.0/Data/MQ2007.rar and parse training set and test set into paddle reader creators
-
-"""
-
-from __future__ import print_function
-
-import os
-import functools
-import rarfile
-from .common import download
-import numpy as np
-
-# URL = "http://research.microsoft.com/en-us/um/beijing/projects/letor/LETOR4.0/Data/MQ2007.rar"
-URL = "http://www.bigdatalab.ac.cn/benchmark/upload/download_source/7b6dbbe2-842c-11e4-a536-bcaec51b9163_MQ2007.rar"
-MD5 = "7be1640ae95c6408dab0ae7207bdc706"
-
-
-def __initialize_meta_info__():
-    """
-  download and extract the MQ2007 dataset
-  """
-    fn = fetch()
-    rar = rarfile.RarFile(fn)
-    dirpath = os.path.dirname(fn)
-    rar.extractall(path=dirpath)
-    return dirpath
-
-
-class Query(object):
-    """
-  queries used for learning to rank algorithms. It is created from relevance scores,  query-document feature vectors
-
-  Parameters:
-  ----------
-  query_id : int
-    query_id in dataset, mapping from query to relevance documents
-  relevance_score : int
-    relevance score of query and document pair
-  feature_vector : array, dense feature
-    feature in vector format
-  description : string
-    comment section in query doc pair data
-  """
-
-    def __init__(self,
-                 query_id=-1,
-                 relevance_score=-1,
-                 feature_vector=None,
-                 description=""):
-        self.query_id = query_id
-        self.relevance_score = relevance_score
-        if feature_vector is None:
-            self.feature_vector = []
-        else:
-            self.feature_vector = feature_vector
-        self.description = description
-
-    def __str__(self):
-        string = "%s %s %s" % (str(self.relevance_score), str(self.query_id),
-                               " ".join(str(f) for f in self.feature_vector))
-        return string
-
-    # @classmethod
-    def _parse_(self, text):
-        """
-    parse line into Query
-    """
-        comment_position = text.find('#')
-        line = text[:comment_position].strip()
-        self.description = text[comment_position + 1:].strip()
-        parts = line.split()
-        if len(parts) != 48:
-            sys.stdout.write("expect 48 space split parts, get %d" %
-                             (len(parts)))
-            return None
-        # format : 0 qid:10 1:0.000272 2:0.000000 ....
-        self.relevance_score = int(parts[0])
-        self.query_id = int(parts[1].split(':')[1])
-        for p in parts[2:]:
-            pair = p.split(':')
-            self.feature_vector.append(float(pair[1]))
-        return self
-
-
-class QueryList(object):
-    """
-  group query into list, every item in list is a Query
-  """
-
-    def __init__(self, querylist=None):
-        self.query_id = -1
-        if querylist is None:
-            self.querylist = []
-        else:
-            self.querylist = querylist
-            for query in self.querylist:
-                if self.query_id == -1:
-                    self.query_id = query.query_id
-                else:
-                    if self.query_id != query.query_id:
-                        raise ValueError("query in list must be same query_id")
-
-    def __iter__(self):
-        for query in self.querylist:
-            yield query
-
-    def __len__(self):
-        return len(self.querylist)
-
-    def __getitem__(self, i):
-        return self.querylist[i]
-
-    def _correct_ranking_(self):
-        if self.querylist is None:
-            return
-        self.querylist.sort(key=lambda x: x.relevance_score, reverse=True)
-
-    def _add_query(self, query):
-        if self.query_id == -1:
-            self.query_id = query.query_id
-        else:
-            if self.query_id != query.query_id:
-                raise ValueError("query in list must be same query_id")
-        self.querylist.append(query)
-
-
-def gen_plain_txt(querylist):
-    """
-  gen plain text in list for other usage
-  Paramters:
-  --------
-  querylist : querylist, one query match many docment pairs in list, see QueryList
-
-  return :
-  ------
-  query_id : np.array, shape=(samples_num, )
-  label : np.array, shape=(samples_num, )
-  querylist : np.array, shape=(samples_num, feature_dimension)
-    """
-    if not isinstance(querylist, QueryList):
-        querylist = QueryList(querylist)
-    querylist._correct_ranking_()
-    for query in querylist:
-        yield querylist.query_id, query.relevance_score, np.array(
-            query.feature_vector)
-
-
-def gen_point(querylist):
-    """
-  gen item in list for point-wise learning to rank algorithm
-  Paramters:
-  --------
-  querylist : querylist, one query match many docment pairs in list, see QueryList
-
-  return :
-  ------
-  label : np.array, shape=(samples_num, )
-  querylist : np.array, shape=(samples_num, feature_dimension)
-  """
-    if not isinstance(querylist, QueryList):
-        querylist = QueryList(querylist)
-    querylist._correct_ranking_()
-    for query in querylist:
-        yield query.relevance_score, np.array(query.feature_vector)
-
-
-def gen_pair(querylist, partial_order="full"):
-    """
-  gen pair for pair-wise learning to rank algorithm
-  Paramters:
-  --------
-  querylist : querylist, one query match many docment pairs in list, see QueryList
-  pairtial_order : "full" or "neighbour"
-    there is redudant in all possiable pair combinations, which can be simplifed
-  gen pairs for neighbour items or the full partial order pairs
-
-  return :
-  ------
-  label : np.array, shape=(1)
-  query_left : np.array, shape=(1, feature_dimension)
-  query_right : same as left
-  """
-    if not isinstance(querylist, QueryList):
-        querylist = QueryList(querylist)
-    querylist._correct_ranking_()
-    labels = []
-    docpairs = []
-
-    # C(n,2)
-    for i in range(len(querylist)):
-        query_left = querylist[i]
-        for j in range(i + 1, len(querylist)):
-            query_right = querylist[j]
-            if query_left.relevance_score > query_right.relevance_score:
-                labels.append([1])
-                docpairs.append([
-                    np.array(query_left.feature_vector),
-                    np.array(query_right.feature_vector)
-                ])
-            elif query_left.relevance_score < query_right.relevance_score:
-                labels.append([1])
-                docpairs.append([
-                    np.array(query_right.feature_vector),
-                    np.array(query_left.feature_vector)
-                ])
-    for label, pair in zip(labels, docpairs):
-        yield np.array(label), pair[0], pair[1]
-
-
-def gen_list(querylist):
-    """
-  gen item in list for list-wise learning to rank algorithm
-  Paramters:
-  --------
-  querylist : querylist, one query match many docment pairs in list, see QueryList
-
-  return :
-  ------
-  label : np.array, shape=(samples_num, )
-  querylist : np.array, shape=(samples_num, feature_dimension)
-  """
-    if not isinstance(querylist, QueryList):
-        querylist = QueryList(querylist)
-    querylist._correct_ranking_()
-    relevance_score_list = [[query.relevance_score] for query in querylist]
-    feature_vector_list = [query.feature_vector for query in querylist]
-    yield np.array(relevance_score_list), np.array(feature_vector_list)
-
-
-def query_filter(querylists):
-    """
-    filter query get only document with label 0.
-    label 0, 1, 2 means the relevance score document with query
-    parameters :
-      querylist : QueyList list
-
-    return :
-      querylist : QueyList list
-    """
-    filter_query = []
-    for querylist in querylists:
-        relevance_score_list = [query.relevance_score for query in querylist]
-        if sum(relevance_score_list) != .0:
-            filter_query.append(querylist)
-    return filter_query
-
-
-def load_from_text(filepath, shuffle=False, fill_missing=-1):
-    """
-  parse data file into querys
-  """
-    prev_query_id = -1
-    querylists = []
-    querylist = None
-    fn = __initialize_meta_info__()
-    with open(os.path.join(fn, filepath)) as f:
-        for line in f:
-            query = Query()
-            query = query._parse_(line)
-            if query == None:
-                continue
-            if query.query_id != prev_query_id:
-                if querylist is not None:
-                    querylists.append(querylist)
-                querylist = QueryList()
-                prev_query_id = query.query_id
-            querylist._add_query(query)
-    if querylist is not None:
-        querylists.append(querylist)
-    return querylists
-
-
-def __reader__(filepath, format="pairwise", shuffle=False, fill_missing=-1):
-    """
-  Parameters
-  --------
-  filename : string
-  fill_missing : fill the missing value. default in MQ2007 is -1
-
-  Returns
-  ------
-  yield
-    label query_left, query_right  # format = "pairwise"
-    label querylist # format = "listwise"
-  """
-    querylists = query_filter(
-        load_from_text(
-            filepath, shuffle=shuffle, fill_missing=fill_missing))
-    for querylist in querylists:
-        if format == "plain_txt":
-            yield next(gen_plain_txt(querylist))
-        elif format == "pointwise":
-            yield next(gen_point(querylist))
-        elif format == "pairwise":
-            for pair in gen_pair(querylist):
-                yield pair
-        elif format == "listwise":
-            yield next(gen_list(querylist))
-
-
-train = functools.partial(__reader__, filepath="MQ2007/MQ2007/Fold1/train.txt")
-test = functools.partial(__reader__, filepath="MQ2007/MQ2007/Fold1/test.txt")
-
-
-def fetch():
-    return download(URL, "MQ2007", MD5)
-
-
-if __name__ == "__main__":
-    fetch()
-    mytest = functools.partial(
-        __reader__, filepath="MQ2007/MQ2007/Fold1/sample", format="listwise")
-    for label, query in mytest():
-        print(label, query)

python/paddle/dataset/sentiment.py

-# /usr/bin/env python
-# -*- coding:utf-8 -*-
-
-# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-The script fetch and preprocess movie_reviews data set that provided by NLTK
-
-TODO(yuyang18): Complete dataset.
-"""
-
-from __future__ import print_function
-
-import six
-import collections
-from itertools import chain
-
-import os
-import nltk
-from nltk.corpus import movie_reviews
-import zipfile
-from functools import cmp_to_key
-
-import paddle.dataset.common
-
-URL = "https://corpora.bj.bcebos.com/movie_reviews%2Fmovie_reviews.zip"
-MD5 = '155de2b77c6834dd8eea7cbe88e93acb'
-
-__all__ = ['train', 'test', 'get_word_dict']
-NUM_TRAINING_INSTANCES = 1600
-NUM_TOTAL_INSTANCES = 2000
-
-
-def download_data_if_not_yet():
-    """
-    Download the data set, if the data set is not download.
-    """
-    try:
-        # download and extract movie_reviews.zip
-        paddle.dataset.common.download(
-            URL, 'corpora', md5sum=MD5, save_name='movie_reviews.zip')
-        path = os.path.join(paddle.dataset.common.DATA_HOME, 'corpora')
-        filename = os.path.join(path, 'movie_reviews.zip')
-        zip_file = zipfile.ZipFile(filename)
-        zip_file.extractall(path)
-        zip_file.close()
-        # make sure that nltk can find the data
-        if paddle.dataset.common.DATA_HOME not in nltk.data.path:
-            nltk.data.path.append(paddle.dataset.common.DATA_HOME)
-        movie_reviews.categories()
-    except LookupError:
-        print("Downloading movie_reviews data set, please wait.....")
-        nltk.download(
-            'movie_reviews', download_dir=paddle.dataset.common.DATA_HOME)
-        print("Download data set success.....")
-        print("Path is " + nltk.data.find('corpora/movie_reviews').path)
-
-
-def get_word_dict():
-    """
-    Sorted the words by the frequency of words which occur in sample
-    :return:
-        words_freq_sorted
-    """
-    words_freq_sorted = list()
-    word_freq_dict = collections.defaultdict(int)
-    download_data_if_not_yet()
-
-    for category in movie_reviews.categories():
-        for field in movie_reviews.fileids(category):
-            for words in movie_reviews.words(field):
-                word_freq_dict[words] += 1
-    words_sort_list = list(six.iteritems(word_freq_dict))
-    words_sort_list.sort(key=cmp_to_key(lambda a, b: b[1] - a[1]))
-    for index, word in enumerate(words_sort_list):
-        words_freq_sorted.append((word[0], index))
-    return words_freq_sorted
-
-
-def sort_files():
-    """
-    Sorted the sample for cross reading the sample
-    :return:
-        files_list
-    """
-    files_list = list()
-    neg_file_list = movie_reviews.fileids('neg')
-    pos_file_list = movie_reviews.fileids('pos')
-    files_list = list(
-        chain.from_iterable(list(zip(neg_file_list, pos_file_list))))
-    return files_list
-
-
-def load_sentiment_data():
-    """
-    Load the data set
-    :return:
-        data_set
-    """
-    data_set = list()
-    download_data_if_not_yet()
-    words_ids = dict(get_word_dict())
-    for sample_file in sort_files():
-        words_list = list()
-        category = 0 if 'neg' in sample_file else 1
-        for word in movie_reviews.words(sample_file):
-            words_list.append(words_ids[word.lower()])
-        data_set.append((words_list, category))
-    return data_set
-
-
-def reader_creator(data):
-    """
-    Reader creator, generate an iterator for data set
-    :param data:
-        train data set or test data set
-    """
-    for each in data:
-        yield each[0], each[1]
-
-
-def train():
-    """
-    Default training set reader creator
-    """
-    data_set = load_sentiment_data()
-    return reader_creator(data_set[0:NUM_TRAINING_INSTANCES])
-
-
-def test():
-    """
-    Default test set reader creator
-    """
-    data_set = load_sentiment_data()
-    return reader_creator(data_set[NUM_TRAINING_INSTANCES:])
-
-
-def fetch():
-    nltk.download('movie_reviews', download_dir=paddle.dataset.common.DATA_HOME)

python/paddle/dataset/tests/test_sentiment.py

-# /usr/bin/env python
-# -*- coding:utf-8 -*-
-
-# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import print_function
-
-import unittest
-import nltk
-import paddle.dataset.sentiment as st
-from nltk.corpus import movie_reviews
-
-
-class TestSentimentMethods(unittest.TestCase):
-    def test_get_word_dict(self):
-        word_dict = st.get_word_dict()[0:10]
-        test_word_list = [(',', 0), ('the', 1), ('.', 2), ('a', 3), ('and', 4),
-                          ('of', 5), ('to', 6), ("'", 7), ('is', 8), ('in', 9)]
-        for idx, each in enumerate(word_dict):
-            self.assertEqual(each, test_word_list[idx])
-        self.assertTrue("/root/.cache/paddle/dataset" in nltk.data.path)
-
-    def test_sort_files(self):
-        last_label = ''
-        for sample_file in st.sort_files():
-            current_label = sample_file.split("/")[0]
-            self.assertNotEqual(current_label, last_label)
-            last_label = current_label
-
-    def test_data_set(self):
-        data_set = st.load_sentiment_data()
-        last_label = -1
-        for each in st.test():
-            self.assertNotEqual(each[1], last_label)
-            last_label = each[1]
-        self.assertEqual(len(data_set), st.NUM_TOTAL_INSTANCES)
-        self.assertEqual(len(list(st.train())), st.NUM_TRAINING_INSTANCES)
-        self.assertEqual(
-            len(list(st.test())),
-            (st.NUM_TOTAL_INSTANCES - st.NUM_TRAINING_INSTANCES))
-
-
-if __name__ == '__main__':
-    unittest.main()

python/paddle/dataset/uci_housing.py

-# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-UCI Housing dataset.
-
-This module will download dataset from
-https://archive.ics.uci.edu/ml/machine-learning-databases/housing/ and
-parse training set and test set into paddle reader creators.
-"""
-
-from __future__ import print_function
-
-import numpy as np
-import six
-import tempfile
-import tarfile
-import os
-import paddle.dataset.common
-
-__all__ = ['train', 'test']
-
-URL = 'http://paddlemodels.bj.bcebos.com/uci_housing/housing.data'
-MD5 = 'd4accdce7a25600298819f8e28e8d593'
-feature_names = [
-    'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
-    'PTRATIO', 'B', 'LSTAT'
-]
-
-UCI_TRAIN_DATA = None
-UCI_TEST_DATA = None
-
-FLUID_URL_MODEL = 'https://github.com/PaddlePaddle/book/raw/develop/01.fit_a_line/fluid/fit_a_line.fluid.tar'
-FLUID_MD5_MODEL = '6e6dd637ccd5993961f68bfbde46090b'
-
-
-def feature_range(maximums, minimums):
-    import matplotlib
-    matplotlib.use('Agg')
-    import matplotlib.pyplot as plt
-    fig, ax = plt.subplots()
-    feature_num = len(maximums)
-    ax.bar(list(range(feature_num)),
-           maximums - minimums,
-           color='r',
-           align='center')
-    ax.set_title('feature scale')
-    plt.xticks(list(range(feature_num)), feature_names)
-    plt.xlim([-1, feature_num])
-    fig.set_figheight(6)
-    fig.set_figwidth(10)
-    if not os.path.exists('./image'):
-        os.makedirs('./image')
-    fig.savefig('image/ranges.png', dpi=48)
-    plt.close(fig)
-
-
-def load_data(filename, feature_num=14, ratio=0.8):
-    global UCI_TRAIN_DATA, UCI_TEST_DATA
-    if UCI_TRAIN_DATA is not None and UCI_TEST_DATA is not None:
-        return
-
-    data = np.fromfile(filename, sep=' ')
-    data = data.reshape(data.shape[0] // feature_num, feature_num)
-    maximums, minimums, avgs = data.max(axis=0), data.min(axis=0), data.sum(
-        axis=0) / data.shape[0]
-    feature_range(maximums[:-1], minimums[:-1])
-    for i in six.moves.range(feature_num - 1):
-        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])
-    offset = int(data.shape[0] * ratio)
-    UCI_TRAIN_DATA = data[:offset]
-    UCI_TEST_DATA = data[offset:]
-
-
-def train():
-    """
-    UCI_HOUSING training set creator.
-
-    It returns a reader creator, each sample in the reader is features after
-    normalization and price number.
-
-    :return: Training reader creator
-    :rtype: callable
-    """
-    global UCI_TRAIN_DATA
-    load_data(paddle.dataset.common.download(URL, 'uci_housing', MD5))
-
-    def reader():
-        for d in UCI_TRAIN_DATA:
-            yield d[:-1], d[-1:]
-
-    return reader
-
-
-def test():
-    """
-    UCI_HOUSING test set creator.
-
-    It returns a reader creator, each sample in the reader is features after
-    normalization and price number.
-
-    :return: Test reader creator
-    :rtype: callable
-    """
-    global UCI_TEST_DATA
-    load_data(paddle.dataset.common.download(URL, 'uci_housing', MD5))
-
-    def reader():
-        for d in UCI_TEST_DATA:
-            yield d[:-1], d[-1:]
-
-    return reader
-
-
-def fluid_model():
-    parameter_tar = paddle.dataset.common.download(
-        FLUID_URL_MODEL, 'uci_housing', FLUID_MD5_MODEL, 'fit_a_line.fluid.tar')
-
-    tar = tarfile.TarFile(parameter_tar, mode='r')
-    dirpath = tempfile.mkdtemp()
-    tar.extractall(path=dirpath)
-
-    return dirpath
-
-
-def predict_reader():
-    """
-    It returns just one tuple data to do inference.
-
-    :return: one tuple data
-    :rtype: tuple
-    """
-    global UCI_TEST_DATA
-    load_data(paddle.dataset.common.download(URL, 'uci_housing', MD5))
-    return (UCI_TEST_DATA[0][:-1], )
-
-
-def fetch():
-    paddle.dataset.common.download(URL, 'uci_housing', MD5)

python/paddle/fluid/contrib/__init__.py

@@ -24,14 +24,10 @@ from . import quantize
 from .quantize import *
 from . import reader
 from .reader import *
-from . import slim
-from .slim import *
 from . import utils
 from .utils import *
 from . import extend_optimizer
 from .extend_optimizer import *
-from . import model_stat
-from .model_stat import *
 from . import mixed_precision
 from .mixed_precision import *
 from . import layers
@@ -43,7 +39,6 @@ __all__ += memory_usage_calc.__all__
 __all__ += op_frequence.__all__
 __all__ += quantize.__all__
 __all__ += reader.__all__
-__all__ += slim.__all__
 __all__ += utils.__all__
 __all__ += extend_optimizer.__all__
 __all__ += ['mixed_precision']

python/paddle/fluid/contrib/model_stat.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-'''
-Example:
-    >>from paddle.fluid.contrib.model_stat import summary
-    >>main_program = ...
-    >>summary(main_program)
-    +-----+------------+----------------+----------------+---------+------------+
-    | No. |       TYPE |          INPUT |         OUTPUT |  PARAMs |      FLOPs |
-    +-----+------------+----------------+----------------+---------+------------+
-    |   0 |     conv2d |  (3, 200, 200) | (64, 100, 100) |    9408 |  188160000 |
-    |   1 | batch_norm | (64, 100, 100) | (64, 100, 100) |     256 |     640000 |
-    |   2 |       relu | (64, 100, 100) | (64, 100, 100) |       0 |     640000 |
-    |   3 |     pool2d | (64, 100, 100) |   (64, 50, 50) |       0 |    1440000 |
-    ...
-    | 176 |     conv2d |    (512, 7, 7) |    (512, 7, 7) | 2359296 |  231211008 |
-    | 177 |       relu |    (512, 7, 7) |    (512, 7, 7) |       0 |      25088 |
-    | 178 |     conv2d |    (512, 7, 7) |   (2048, 7, 7) | 1048576 |  102760448 |
-    | 179 |       relu |   (2048, 7, 7) |   (2048, 7, 7) |       0 |     100352 |
-    | 180 |     pool2d |   (2048, 7, 7) |   (2048, 1, 1) |       0 |     100352 |
-    +-----+------------+----------------+----------------+---------+------------+
-    Total PARAMs: 48017344(0.0480G)
-    Total FLOPs: 11692747751(11.69G)
-'''
-from collections import OrderedDict
-from prettytable import PrettyTable
-
-
-def summary(main_prog):
-    '''
-    It can summary model's PARAMS, FLOPs until now.
-    It support common operator like conv, fc, pool, relu, sigmoid, bn etc. 
-    Args:
-        main_prog: main program 
-    Returns:
-        print summary on terminal
-    '''
-    collected_ops_list = []
-    for one_b in main_prog.blocks:
-        block_vars = one_b.vars
-        for one_op in one_b.ops:
-            op_info = OrderedDict()
-            spf_res = _summary_model(block_vars, one_op)
-            if spf_res is None:
-                continue
-            # TODO: get the operator name
-            op_info['type'] = one_op.type
-            op_info['input_shape'] = spf_res[0][1:]
-            op_info['out_shape'] = spf_res[1][1:]
-            op_info['PARAMs'] = spf_res[2]
-            op_info['FLOPs'] = spf_res[3]
-            collected_ops_list.append(op_info)
-
-    summary_table, total = _format_summary(collected_ops_list)
-    _print_summary(summary_table, total)
-
-
-def _summary_model(block_vars, one_op):
-    '''
-    Compute operator's params and flops.
-    Args:
-        block_vars: all vars of one block
-        one_op: one operator to count
-    Returns:
-        in_data_shape: one operator's input data shape
-        out_data_shape: one operator's output data shape
-        params: one operator's PARAMs 
-        flops: : one operator's FLOPs
-    '''
-    if one_op.type in ['conv2d', 'depthwise_conv2d']:
-        k_arg_shape = block_vars[one_op.input("Filter")[0]].shape
-        in_data_shape = block_vars[one_op.input("Input")[0]].shape
-        out_data_shape = block_vars[one_op.output("Output")[0]].shape
-        c_out, c_in, k_h, k_w = k_arg_shape
-        _, c_out_, h_out, w_out = out_data_shape
-        assert c_out == c_out_, 'shape error!'
-        k_groups = one_op.attr("groups")
-        kernel_ops = k_h * k_w * (c_in / k_groups)
-        bias_ops = 0 if one_op.input("Bias") == [] else 1
-        params = c_out * (kernel_ops + bias_ops)
-        flops = h_out * w_out * c_out * (kernel_ops + bias_ops)
-        # base nvidia paper, include mul and add
-        flops = 2 * flops
-
-    elif one_op.type == 'pool2d':
-        in_data_shape = block_vars[one_op.input("X")[0]].shape
-        out_data_shape = block_vars[one_op.output("Out")[0]].shape
-        _, c_out, h_out, w_out = out_data_shape
-        k_size = one_op.attr("ksize")
-        params = 0
-        flops = h_out * w_out * c_out * (k_size[0] * k_size[1])
-
-    elif one_op.type == 'mul':
-        k_arg_shape = block_vars[one_op.input("Y")[0]].shape
-        in_data_shape = block_vars[one_op.input("X")[0]].shape
-        out_data_shape = block_vars[one_op.output("Out")[0]].shape
-        # TODO: fc has mul ops
-        # add attr to mul op, tell us whether it belongs to 'fc'
-        # this's not the best way
-        if 'fc' not in one_op.output("Out")[0]:
-            return None
-        k_in, k_out = k_arg_shape
-        # bias in sum op
-        params = k_in * k_out + 1
-        flops = k_in * k_out
-
-    elif one_op.type in ['sigmoid', 'tanh', 'relu', 'leaky_relu', 'prelu']:
-        in_data_shape = block_vars[one_op.input("X")[0]].shape
-        out_data_shape = block_vars[one_op.output("Out")[0]].shape
-        params = 0
-        if one_op.type == 'prelu':
-            params = 1
-        flops = 1
-        for one_dim in in_data_shape:
-            flops *= one_dim
-
-    elif one_op.type == 'batch_norm':
-        in_data_shape = block_vars[one_op.input("X")[0]].shape
-        out_data_shape = block_vars[one_op.output("Y")[0]].shape
-        _, c_in, h_out, w_out = in_data_shape
-        # gamma, beta
-        params = c_in * 2
-        # compute mean and std
-        flops = h_out * w_out * c_in * 2
-
-    else:
-        return None
-
-    return in_data_shape, out_data_shape, params, flops
-
-
-def _format_summary(collected_ops_list):
-    '''
-    Format summary report.
-    Args:
-        collected_ops_list: the collected operator with summary
-    Returns:
-        summary_table: summary report format
-        total: sum param and flops
-    '''
-    summary_table = PrettyTable(
-        ["No.", "TYPE", "INPUT", "OUTPUT", "PARAMs", "FLOPs"])
-    summary_table.align = 'r'
-
-    total = {}
-    total_params = []
-    total_flops = []
-    for i, one_op in enumerate(collected_ops_list):
-        # notice the order
-        table_row = [
-            i,
-            one_op['type'],
-            one_op['input_shape'],
-            one_op['out_shape'],
-            int(one_op['PARAMs']),
-            int(one_op['FLOPs']),
-        ]
-        summary_table.add_row(table_row)
-        total_params.append(int(one_op['PARAMs']))
-        total_flops.append(int(one_op['FLOPs']))
-
-    total['params'] = total_params
-    total['flops'] = total_flops
-
-    return summary_table, total
-
-
-def _print_summary(summary_table, total):
-    '''
-    Print all the summary on terminal.
-    Args:
-        summary_table: summary report format
-        total: sum param and flops
-    '''
-    parmas = total['params']
-    flops = total['flops']
-    print(summary_table)
-    print('Total PARAMs: {}({:.4f}M)'.format(
-        sum(parmas), sum(parmas) / (10**6)))
-    print('Total FLOPs: {}({:.2f}G)'.format(sum(flops), sum(flops) / 10**9))
-    print(
-        "Notice: \n now supported ops include [Conv, DepthwiseConv, FC(mul), BatchNorm, Pool, Activation(sigmoid, tanh, relu, leaky_relu, prelu)]"
-    )

python/paddle/fluid/contrib/slim/__init__.py

-#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .core import *
-__all__ = ['Compressor', ]

python/paddle/fluid/contrib/slim/core/__init__.py

-#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import config
-from .config import *
-from . import compressor
-from .compressor import *
-from . import strategy
-from .strategy import *
-
-__all__ = config.__all__ + compressor.__all__ + strategy.__all__

python/paddle/fluid/contrib/slim/core/config.py

-#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-import funcsigs
-import yaml
-from collections import OrderedDict
-from ..prune import *
-from ..quantization import *
-from .strategy import *
-from ..distillation import *
-from ..searcher import *
-from ..nas import *
-
-__all__ = ['ConfigFactory']
-"""This factory is used to create instances by loading and parsing configure file with yaml format.
-"""
-
-PLUGINS = ['pruners', 'quantizers', 'distillers', 'strategies', 'controllers']
-
-
-class ConfigFactory(object):
-    def __init__(self, config):
-        """Init a factory from configure file."""
-        self.instances = {}
-        self.compressor = {}
-        self.version = None
-        self._parse_config(config)
-
-    def instance(self, name):
-        """
-        Get instance from factory.
-        """
-        if name in self.instances:
-            return self.instances[name]
-        else:
-            return None
-
-    def _new_instance(self, name, attrs):
-        if name not in self.instances:
-            class_ = globals()[attrs['class']]
-            sig = funcsigs.signature(class_.__init__)
-            keys = [
-                param.name for param in sig.parameters.values()
-                if (param.kind == param.POSITIONAL_OR_KEYWORD)
-            ][1:]
-            keys = set(attrs.keys()).intersection(set(keys))
-            args = {}
-            for key in keys:
-                value = attrs[key]
-                if isinstance(value, str) and value.lower() == 'none':
-                    value = None
-                if isinstance(value, str) and value in self.instances:
-                    value = self.instances[value]
-                if isinstance(value, list):
-                    for i in range(len(value)):
-                        if isinstance(value[i],
-                                      str) and value[i] in self.instances:
-                            value[i] = self.instances[value[i]]
-
-                args[key] = value
-            self.instances[name] = class_(**args)
-        return self.instances.get(name)
-
-    def _parse_config(self, config):
-        assert config
-        with open(config, 'r') as config_file:
-            key_values = self._ordered_load(config_file)
-            for key in key_values:
-                # parse version
-                if key == 'version' and self.version is None:
-                    self.version = int(key_values['version'])
-                    assert self.version == int(key_values['version'])
-
-                # parse pruners
-                if key in PLUGINS:
-                    instances = key_values[key]
-                    for name in instances:
-                        self._new_instance(name, instances[name])
-
-                if key == 'compressor':
-                    self.compressor['strategies'] = []
-                    self.compressor['epoch'] = key_values[key]['epoch']
-                    if 'init_model' in key_values[key]:
-                        self.compressor['init_model'] = key_values[key][
-                            'init_model']
-                    if 'checkpoint_path' in key_values[key]:
-                        self.compressor['checkpoint_path'] = key_values[key][
-                            'checkpoint_path']
-                    if 'eval_epoch' in key_values[key]:
-                        self.compressor['eval_epoch'] = key_values[key][
-                            'eval_epoch']
-                    if 'strategies' in key_values[key]:
-                        for name in key_values[key]['strategies']:
-                            strategy = self.instance(name)
-                            self.compressor['strategies'].append(strategy)
-
-                if key == 'include':
-                    for config_file in key_values[key]:
-                        self._parse_config(config_file.strip())
-
-    def _ordered_load(self,
-                      stream,
-                      Loader=yaml.Loader,
-                      object_pairs_hook=OrderedDict):
-        """
-        See: https://stackoverflow.com/questions/5121931/in-python-how-can-you-load-yaml-mappings-as-ordereddicts
-        """
-
-        class OrderedLoader(Loader):
-            pass
-
-        def construct_mapping(loader, node):
-            loader.flatten_mapping(node)
-            return object_pairs_hook(loader.construct_pairs(node))
-
-        OrderedLoader.add_constructor(
-            yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, construct_mapping)
-        return yaml.load(stream, OrderedLoader)

python/paddle/fluid/contrib/slim/core/strategy.py

-#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-__all__ = ['Strategy']
-
-
-class Strategy(object):
-    """
-    Base class for all strategies.
-    """
-
-    def __init__(self, start_epoch=0, end_epoch=0):
-        """
-        Args:
-            start_epoch: The first epoch to apply the strategy.
-            end_epoch: The last epoch to apply the strategy.
-        """
-        self.start_epoch = start_epoch
-        self.end_epoch = end_epoch
-
-    def __getstate__(self):
-        d = {}
-        for key in self.__dict__:
-            if key not in ["start_epoch", "end_epoch"]:
-                d[key] = self.__dict__[key]
-        return d
-
-    def on_compression_begin(self, context):
-        pass
-
-    def on_epoch_begin(self, context):
-        pass
-
-    def on_epoch_end(self, context):
-        pass
-
-    def on_batch_begin(self, context):
-        pass
-
-    def on_batch_end(self, context):
-        pass
-
-    def on_compression_end(self, context):
-        pass
-
-    def restore_from_checkpoint(self, context):
-        pass

python/paddle/fluid/contrib/slim/distillation/__init__.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import distiller
-from .distiller import *
-from . import distillation_strategy
-from .distillation_strategy import *
-
-__all__ = distiller.__all__
-__all__ += distillation_strategy.__all__

python/paddle/fluid/contrib/slim/distillation/distillation_strategy.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from ..core.strategy import Strategy
-from ....framework import Program, Variable, program_guard
-from ....log_helper import get_logger
-from .... import Executor
-import logging
-
-__all__ = ['DistillationStrategy']
-
-_logger = get_logger(
-    __name__, logging.INFO, fmt='%(asctime)s-%(levelname)s: %(message)s')
-
-
-class DistillationStrategy(Strategy):
-    def __init__(self, distillers=None, start_epoch=0, end_epoch=0):
-        """
-        Args:
-            distillers(list): A list of distiller used to combine student graph and teacher graph
-                              by adding some loss.
-            start_epoch(int): The epoch when to merge student graph and teacher graph for
-                              distillation training. default: 0
-            end_epoch(int): The epoch when to finish distillation training. default: 0
-            
-        """
-        super(DistillationStrategy, self).__init__(start_epoch, end_epoch)
-        self.distillers = distillers
-
-    def restore_from_checkpoint(self, context):
-        # load from checkpoint
-        if context.epoch_id > 0:
-            if context.epoch_id > self.start_epoch and context.epoch_id < self.end_epoch:
-                _logger.info('Restore DistillationStrategy')
-                self._create_distillation_graph(context)
-                _logger.info('Restore DistillationStrategy finish.')
-
-    def on_epoch_begin(self, context):
-        if self.start_epoch == context.epoch_id:
-            _logger.info('DistillationStrategy::on_epoch_begin.')
-            self._create_distillation_graph(context)
-            _logger.info('DistillationStrategy set optimize_graph.')
-
-    def _create_distillation_graph(self, context):
-        """
-        step 1: Merge student graph and teacher graph into distillation graph.
-        step 2: Add loss into distillation graph by distillers.
-        step 3: Append backward ops and optimize ops into distillation graph for training.
-        """
-        # step 1
-        teacher = context.teacher_graphs[0]
-        for var in teacher.program.list_vars():
-            var.stop_gradient = True
-        graph = context.train_graph.clone()
-        graph.merge(teacher)
-        if 'loss' in graph.out_nodes:
-            graph.out_nodes['student_loss'] = graph.out_nodes['loss']
-
-        # step 2
-        for distiller in self.distillers:
-            graph = distiller.distiller_loss(graph)
-
-        # step 3
-        startup_program = Program()
-        with program_guard(graph.program, startup_program):
-            context.distiller_optimizer._name = 'distillation_optimizer'
-
-            # The learning rate variable may be created in other program.
-            # Update information in optimizer to make
-            # learning rate variable being accessible in current program.
-            optimizer = context.distiller_optimizer
-            if isinstance(optimizer._learning_rate, Variable):
-                optimizer._learning_rate_map[
-                    graph.program] = optimizer._learning_rate
-
-            optimizer.minimize(graph.var(graph.out_nodes['loss'])._var)
-
-        exe = Executor(context.place)
-        exe.run(startup_program, scope=context.scope)
-
-        # backup graph for fine-tune after distillation
-        context.put('distillation_backup_optimize_graph',
-                    context.optimize_graph)
-        context.optimize_graph = graph
-
-    def on_epoch_end(self, context):
-        if context.epoch_id == (self.end_epoch - 1):
-            _logger.info('DistillationStrategy::on_epoch_end.')
-            # restore optimize_graph for fine-tune or other strategy in next stage.
-            context.optimize_graph = context.get(
-                'distillation_backup_optimize_graph')
-            _logger.info(
-                'DistillationStrategy set context.optimize_graph to None.')

python/paddle/fluid/contrib/slim/distillation/distiller.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .... import layers
-from .... import optimizer
-from .... import Executor
-from .... import Program
-from .... import program_guard
-from .... import regularizer
-
-__all__ = ['FSPDistiller', 'L2Distiller', 'SoftLabelDistiller']
-
-
-class L2Distiller(object):
-    """
-    Combine two layers from student net and teacher net by l2-loss.
-    And add the loss into the total loss using for distillation training.
-    """
-
-    def __init__(self,
-                 student_feature_map,
-                 teacher_feature_map,
-                 distillation_loss_weight=1):
-        """
-        Args:
-            student_feature_map(str): The name of feature map from student network.
-            teacher_feature_map(str): The name of feature map from teacher network.
-                                      It's shape should be the same with student network.
-            distillation_loss_weight(float): The weight of the l2-loss.
-        """
-        self.student_feature_map = student_feature_map
-        self.teacher_feature_map = teacher_feature_map
-        self.distillation_loss_weight = distillation_loss_weight
-
-    def distiller_loss(self, graph):
-        """
-        Modify graph inplace to add l2-loss.
-        Args: 
-            graph(GraphWrapper): The graph to be modified.
-        Returns:
-            GraphWrapper: The modified graph.
-        """
-        distiller_pass = L2DistillerPass(self.student_feature_map,
-                                         self.teacher_feature_map,
-                                         self.distillation_loss_weight)
-        dis_graph = distiller_pass.apply(graph)
-        return dis_graph
-
-
-class L2DistillerPass(object):
-    """
-    The pass used to add l2-loss.
-    """
-
-    def __init__(self,
-                 student_feature_map,
-                 teacher_feature_map,
-                 distillation_loss_weight=1):
-        """
-        Args:
-            student_feature_map(str): The name of feature map from student network.
-            teacher_feature_map(str): The name of feature map from teacher network.
-                                      It's shape should be the same with student network.
-            distillation_loss_weight(float): The weight of the l2-loss.
-        """
-        self.student_feature_map = student_feature_map
-        self.teacher_feature_map = teacher_feature_map
-        self.distillation_loss_weight = distillation_loss_weight
-
-    def apply(self, graph):
-        ret_graph = graph
-        with program_guard(ret_graph.program):
-
-            student_feature_map = ret_graph.var(self.student_feature_map)._var
-            teacher_feature_map = ret_graph.var(self.teacher_feature_map)._var
-            l2loss = layers.reduce_mean(
-                layers.square(student_feature_map - teacher_feature_map))
-
-            distillation_loss = l2loss * self.distillation_loss_weight
-            student_loss = 0
-            if 'loss' in ret_graph.out_nodes:
-                student_loss = ret_graph.var(ret_graph.out_nodes['loss'])._var
-            loss = distillation_loss + student_loss
-
-            ret_graph.out_nodes['loss'] = loss.name
-            ret_graph.out_nodes[
-                'l2loss_' + self.student_feature_map + "_" +
-                self.teacher_feature_map] = distillation_loss.name
-        return ret_graph
-
-
-class FSPDistiller(object):
-    """
-    Combine layers from student net and teacher net by fsp-loss.
-    """
-
-    def __init__(self, student_pairs, teacher_pairs,
-                 distillation_loss_weight=1):
-        """
-        Args:
-            student_pairs(list<tuple>): Each tuple, with two variable names, in student_pairs indicates
-                                        a section in student network. The variables in a tuple should
-                                        have the same feature map size.
-            teacher_pairs(list<tuple>): Each tuple, with two variable names, in teacher_pairs indicates
-                                        a section in teacher network. The variables in a tuple should
-                                        have the same feature map size. Varibale named teacher_pairs[i][j]
-                                        should has the save channel number with that of variable named 
-                                        student_pairs[i][j].
-
-            distillation_loss_weight(float): The weight of the fsp-loss. default: 1.
-        """
-        self.student_pairs = student_pairs
-        self.teacher_pairs = teacher_pairs
-        self.distillation_loss_weight = distillation_loss_weight
-
-    def distiller_loss(self, graph):
-        """
-        Modify graph inplace to add fsp-loss.
-        Args: 
-            graph(GraphWrapper): The graph to be modified.
-        Returns:
-            GraphWrapper: The modified graph.
-        """
-        distiller_pass = FSPDistillerPass(self.student_pairs,
-                                          self.teacher_pairs,
-                                          self.distillation_loss_weight)
-        dis_graph = distiller_pass.apply(graph)
-        return dis_graph
-
-
-class FSPDistillerPass(object):
-    '''
-    Combine layers from student net and teacher net by fsp-loss.
-    '''
-
-    def __init__(self, s_pairs, t_pairs, distillation_loss_weight=1):
-        """
-        Args:
-            s_pairs(list<tuple>): Each tuple, with two variable names, in student_pairs indicates
-                                        a section in student network. The variables in a tuple should
-                                        have the same feature map size.
-            t_pairs(list<tuple>): Each tuple, with two variable names, in teacher_pairs indicates
-                                        a section in teacher network. The variables in a tuple should
-                                        have the same feature map size. Varibale named teacher_pairs[i][j]
-                                        should has the save channel number with that of variable named 
-                                        student_pairs[i][j].
-
-            distillation_loss_weight(float): The weight of the fsp-loss. default: 1.
-        """
-        self.s_pairs = s_pairs
-        self.t_pairs = t_pairs
-        self.distillation_loss_weight = distillation_loss_weight
-
-    def apply(self, graph):
-        ret_graph = graph
-        with program_guard(ret_graph.program):
-            losses = []
-            for s_pair, t_pair in zip(self.s_pairs, self.t_pairs):
-                s_pair_start = ret_graph.var(s_pair[0])._var
-                s_pair_end = ret_graph.var(s_pair[1])._var
-                s_fsp_matrix = self._fsp_matrix(s_pair_start, s_pair_end)
-                t_pair_start = ret_graph.var(t_pair[0])._var
-                t_pair_end = ret_graph.var(t_pair[1])._var
-                t_fsp_matrix = self._fsp_matrix(t_pair_start, t_pair_end)
-                l2_loss = layers.reduce_mean(
-                    layers.square(s_fsp_matrix - t_fsp_matrix))
-                losses.append(l2_loss)
-            distillation_loss = layers.sum(
-                losses) * self.distillation_loss_weight
-            student_loss = 0
-            if 'loss' in ret_graph.out_nodes:
-                student_loss = ret_graph.var(ret_graph.out_nodes['loss'])._var
-            loss = distillation_loss + student_loss
-
-            ret_graph.out_nodes['loss'] = loss.name
-            ret_graph.out_nodes[
-                'fsp_distillation_loss'] = distillation_loss.name
-        return ret_graph
-
-    def _fsp_matrix(self, fea_map_0, fea_map_1):
-        return layers.fsp_matrix(fea_map_0, fea_map_1)
-
-
-class SoftLabelDistiller(object):
-    """
-    Combine two layers from student net and teacher net by softmax_with_cross_entropy loss.
-    And add the loss into the total loss using for distillation training.
-    """
-
-    def __init__(self,
-                 student_feature_map=None,
-                 teacher_feature_map=None,
-                 student_temperature=1.0,
-                 teacher_temperature=1.0,
-                 distillation_loss_weight=1):
-        """
-        Args:
-            student_feature_map(str): The name of feature map from student network.
-            teacher_feature_map(str): The name of feature map from teacher network.
-                                      It's shape should be the same with student network.
-            student_temperature(float): Temperature used to divide student_feature_map before softmax_with_cross_entropy. default: 1.0
-            teacher_temperature(float): Temperature used to divide teacher_feature_map before softmax_with_cross_entropy. default: 1.0
-            distillation_loss_weight(float): The weight of the l2-loss.
-        """
-
-        self.student_feature_map = student_feature_map
-        self.teacher_feature_map = teacher_feature_map
-        self.distillation_loss_weight = distillation_loss_weight
-        self.student_temperature = student_temperature
-        self.teacher_temperature = teacher_temperature
-
-    def distiller_loss(self, graph):
-        """
-        Modify graph inplace to add softmax_with_cross_entropy loss.
-        Args: 
-            graph(GraphWrapper): The graph to be modified.
-        Returns:
-            GraphWrapper: The modified graph.
-        """
-        distiller_pass = SoftLabelDistillerPass(
-            self.student_feature_map, self.teacher_feature_map,
-            self.student_temperature, self.teacher_temperature,
-            self.distillation_loss_weight)
-        dis_graph = distiller_pass.apply(graph)
-        return dis_graph
-
-
-class SoftLabelDistillerPass(object):
-    def __init__(self,
-                 student_feature_map,
-                 teacher_feature_map,
-                 student_temperature,
-                 teacher_temperature,
-                 distillation_loss_weight=1):
-        """
-        Args:
-            student_feature_map(str): The name of feature map from student network.
-            teacher_feature_map(str): The name of feature map from teacher network.
-                                      It's shape should be the same with student network.
-            student_temperature(float): Temperature used to divide student_feature_map before softmax_with_cross_entropy.
-            teacher_temperature(float): Temperature used to divide teacher_feature_map before softmax_with_cross_entropy.
-            distillation_loss_weight(float): The weight of the l2-loss.
-        """
-        self.student_feature_map = student_feature_map
-        self.teacher_feature_map = teacher_feature_map
-        self.student_temperature = student_temperature
-        self.teacher_temperature = teacher_temperature
-        self.distillation_loss_weight = distillation_loss_weight
-
-    def apply(self, graph):
-        ret_graph = graph
-        with program_guard(ret_graph.program):
-
-            student_feature_map = ret_graph.var(self.student_feature_map)._var
-            teacher_feature_map = ret_graph.var(self.teacher_feature_map)._var
-            s_fea = layers.softmax(student_feature_map /
-                                   self.student_temperature)
-            t_fea = layers.softmax(teacher_feature_map /
-                                   self.teacher_temperature)
-            t_fea.stop_gradient = True
-            ce_loss = layers.reduce_mean(
-                layers.cross_entropy(
-                    s_fea, t_fea, soft_label=True))
-            distillation_loss = ce_loss * self.distillation_loss_weight
-            student_loss = 0
-            if 'loss' in ret_graph.out_nodes:
-                student_loss = ret_graph.var(ret_graph.out_nodes['loss'])._var
-            loss = distillation_loss + student_loss
-
-            ret_graph.out_nodes['loss'] = loss.name
-            ret_graph.out_nodes[
-                'soft_label_loss_' + self.student_feature_map + "_" +
-                self.teacher_feature_map] = distillation_loss.name
-        return ret_graph

python/paddle/fluid/contrib/slim/graph/__init__.py

-#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import executor
-from .executor import *
-from . import graph_wrapper
-from .graph_wrapper import *
-__all__ = executor.__all__
-__all__ += graph_wrapper.__all__

python/paddle/fluid/contrib/slim/graph/executor.py

-#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from ....compiler import CompiledProgram
-from ....data_feeder import DataFeeder
-from .... import executor
-from .graph_wrapper import GraphWrapper
-
-__all__ = ['SlimGraphExecutor']
-
-
-class SlimGraphExecutor(object):
-    """
-    Wrapper of executor used to run GraphWrapper.
-    """
-
-    def __init__(self, place):
-        self.exe = executor.Executor(place)
-        self.place = place
-
-    def run(self, graph, scope, data=None):
-        """
-        Runing a graph with a batch of data.
-        Args:
-            graph(GraphWrapper): The graph to be executed.
-            scope(fluid.core.Scope): The scope to be used.
-            data(list<tuple>): A batch of data. Each tuple in this list is a sample.
-                               It will feed the items of tuple to the in_nodes of graph.
-        Returns:
-            results(list): A list of result with the same order indicated by graph.out_nodes.
-        """
-        assert isinstance(graph, GraphWrapper)
-        feed = None
-        if data is not None and isinstance(data[0], dict):
-            # return list = False
-            feed = data
-        elif data is not None:
-            feeder = DataFeeder(
-                feed_list=list(graph.in_nodes.values()),
-                place=self.place,
-                program=graph.program)
-            feed = feeder.feed(data)
-
-        fetch_list = list(graph.out_nodes.values())
-        program = graph.compiled_graph if graph.compiled_graph else graph.program
-        results = self.exe.run(program,
-                               scope=scope,
-                               fetch_list=fetch_list,
-                               feed=feed)
-        return results

python/paddle/fluid/contrib/slim/graph/graph_wrapper.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from collections import OrderedDict
-from .... import io
-from .... import compiler
-from ....framework import Program
-from ....framework import program_guard
-from ....framework import Parameter
-from ....framework import Variable
-from ....executor import Executor
-import copy
-from collections import Iterable
-from ....io import save_inference_model, load_inference_model, save_persistables
-import numpy as np
-import pickle
-import os
-
-__all__ = ['GraphWrapper', 'VarWrapper', 'OpWrapper']
-
-OPTIMIZER_OPS = [
-    'momentum',
-    'lars_momentum',
-    'adagrad',
-    'adam',
-    'adamax',
-    'dpsgd',
-    'decayed_adagrad',
-    'adadelta',
-    'rmsprop',
-]
-
-
-class VarWrapper(object):
-    def __init__(self, var, graph):
-        assert isinstance(var, Variable)
-        assert isinstance(graph, GraphWrapper)
-        self._var = var
-        self._graph = graph
-
-    def __eq__(self, v):
-        """
-        Overwrite this function for ...in... syntax in python.
-        """
-        return self._var.name == v._var.name
-
-    def name(self):
-        """
-        Get the name of the variable.
-        """
-        return self._var.name
-
-    def shape(self):
-        """
-        Get the shape of the varibale.
-        """
-        return self._var.shape
-
-    def set_shape(self, shape):
-        """
-        Set the shape of the variable.
-        """
-        self._var.desc.set_shape(shape)
-
-    def inputs(self):
-        """
-        Get all the operators that use this variable as output.
-        Returns:
-            list<OpWrapper>: A list of operators.
-        """
-        ops = []
-        for op in self._graph.ops():
-            if self in op.all_inputs():
-                ops.append(op)
-        return ops
-
-    def outputs(self):
-        """
-        Get all the operators that use this variable as input.
-        Returns:
-            list<OpWrapper>: A list of operators.
-        """
-        ops = []
-        for op in self._graph.ops():
-            if self in op.all_outputs():
-                ops.append(op)
-        return ops
-
-
-class OpWrapper(object):
-    def __init__(self, op, graph):
-        assert isinstance(graph, GraphWrapper)
-        self._op = op
-        self._graph = graph
-
-    def __eq__(self, op):
-        """
-        Overwrite this function for ...in... syntax in python.
-        """
-        return self.idx() == op.idx()
-
-    def all_inputs(self):
-        """
-        Get all the input variables of this operator.
-        """
-        return [
-            self._graph.var(var_name) for var_name in self._op.input_arg_names
-        ]
-
-    def all_outputs(self):
-        """
-        Get all the output variables of this operator.
-        """
-        return [
-            self._graph.var(var_name) for var_name in self._op.output_arg_names
-        ]
-
-    def idx(self):
-        """
-        Get the id of this operator.
-        """
-        return self._op.idx
-
-    def type(self):
-        """
-        Get the type of this operator.
-        """
-        return self._op.type
-
-    def is_bwd_op(self):
-        """
-        Whether this operator is backward op.
-        """
-        return self.type().endswith('_grad')
-
-    def is_opt_op(self):
-        """
-        Whether this operator is optimizer op.
-        """
-        return self.type() in OPTIMIZER_OPS
-
-    def inputs(self, name):
-        """
-        Get all the varibales by the input name.
-        """
-        return [self._graph.var(var_name) for var_name in self._op.input(name)]
-
-    def outputs(self, name):
-        """
-        Get all the varibales by the output name.
-        """
-        return [self._graph.var(var_name) for var_name in self._op.output(name)]
-
-    def set_attr(self, key, value):
-        """
-        Set the value of attribute by attribute's name.
-
-        Args:
-            key(str): the attribute name.
-            value(bool|int|str|float|list): the value of the attribute.
-        """
-        self._op._set_attr(key, value)
-
-    def attr(self, name):
-        """
-        Get the attribute by name.
-
-        Args:
-            name(str): the attribute name.
-
-        Returns:
-            bool|int|str|float|list: The attribute value. The return value
-            can be any valid attribute type.
-        """
-        return self._op.attr(name)
-
-
-class GraphWrapper(object):
-    """
-    It is a wrapper of paddle.fluid.framework.IrGraph with some special functions
-    for paddle slim framework.
-    """
-
-    def __init__(self, program=None, in_nodes=[], out_nodes=[]):
-        """
-        Args:
-            program(framework.Program): A program with 
-            in_nodes(dict): A dict to indicate the input nodes of the graph.
-                            The key is user-defined and human-readable name.
-                            The value is the name of Variable.
-            out_nodes(dict): A dict to indicate the input nodes of the graph.
-                            The key is user-defined and human-readable name.
-                            The value is the name of Variable.
-        """
-        super(GraphWrapper, self).__init__()
-        self.program = Program() if program is None else program
-        self.persistables = {}
-        self.teacher_persistables = {}
-        for var in self.program.list_vars():
-            if var.persistable:
-                self.persistables[var.name] = var
-        self.compiled_graph = None
-        in_nodes = [] if in_nodes is None else in_nodes
-        out_nodes = [] if out_nodes is None else out_nodes
-        self.in_nodes = OrderedDict(in_nodes)
-        self.out_nodes = OrderedDict(out_nodes)
-        self._attrs = OrderedDict()
-
-    def all_parameters(self):
-        """
-        Get all the parameters in this graph.
-        Returns:
-            list<VarWrapper>: A list of VarWrapper instances.
-        """
-        params = []
-        for block in self.program.blocks:
-            for param in block.all_parameters():
-                params.append(VarWrapper(param, self))
-        return params
-
-    def is_parameter(self, var):
-        """
-        Whether the given variable is parameter.
-        Args:
-            var(VarWrapper): The given varibale.
-        """
-        return isinstance(var._var, Parameter)
-
-    def is_persistable(self, var):
-        """
-        Whether the given variable is persistable.
-        Args:
-            var(VarWrapper): The given varibale.
-        """
-        return var._var.persistable
-
-    def compile(self, for_parallel=True, for_test=False, mem_opt=False):
-        """
-        Compile the program in this wrapper to framework.CompiledProgram for next running.
-        This function must be called if the program is modified.
-        Args:
-            for_parallel(bool): Whether the program to run in data parallel way. default: True.
-            for_test(bool): Whether the compiled program is used for test.
-        """
-        target = self.program
-        if for_test:
-            loss = None
-        else:
-            loss = self.out_nodes['loss']
-        if for_parallel:
-            # disable memory optimize for stable training
-            build_strategy = compiler.BuildStrategy()
-            build_strategy.enable_inplace = mem_opt
-            build_strategy.memory_optimize = mem_opt
-            build_strategy.fuse_all_reduce_ops = False
-            #            build_strategy.async_mode = False
-            self.compiled_graph = compiler.CompiledProgram(
-                target).with_data_parallel(
-                    loss_name=loss, build_strategy=build_strategy)
-        else:
-            self.compiled_graph = compiler.CompiledProgram(target)
-
-    def ops(self):
-        """
-        Return all operator nodes included in the graph as a set.
-        """
-        ops = []
-        for block in self.program.blocks:
-            for op in block.ops:
-                ops.append(OpWrapper(op, self))
-        return ops
-
-    def vars(self):
-        """
-        Get all the variables.
-        """
-        return [VarWrapper(var, self) for var in self.program.list_vars()]
-
-    def var(self, name):
-        """
-        Get the variable by variable name.
-        """
-        return VarWrapper(self.program.global_block().var(name), self)
-
-    def clone(self, for_test=False):
-        """
-        Clone a new graph from current graph.
-        Returns:
-            (GraphWrapper): The wrapper of a new graph.
-        """
-        return GraphWrapper(
-            self.program.clone(for_test),
-            copy.deepcopy(self.in_nodes), copy.deepcopy(self.out_nodes))
-
-    def merge(self, graph):
-        """
-        Merge a graph into current graph.
-        Args:
-            graph(GraphWrapper): The graph to be merged by current graph.
-        """
-        for var in graph.program.list_vars():
-            if var.persistable:
-                self.teacher_persistables[var.name] = var
-            new_var = self.program.global_block()._clone_variable(
-                var, force_persistable=False)
-            new_var.stop_gradient = var.stop_gradient
-            # TODO: parameters should be cloned
-        for op in graph.ops():
-            op = op._op
-            inputs = {}
-            outputs = {}
-            attrs = {}
-            for input_name in op.input_names:
-                inputs[input_name] = [
-                    self.var(in_var_name)._var
-                    for in_var_name in op.input(input_name)
-                ]
-            for output_name in op.output_names:
-                outputs[output_name] = [
-                    self.var(out_var_name)._var
-                    for out_var_name in op.output(output_name)
-                ]
-            for attr_name in op.attr_names:
-                attrs[attr_name] = op.attr(attr_name)
-            self.program.global_block().append_op(
-                type=op.type, inputs=inputs, outputs=outputs, attrs=attrs)
-
-    def program(self):
-        """
-        Get the program in current wrapper.
-        """
-        return self.program
-
-    def pre_ops(self, op):
-        """
-        Get all the previous operators of target operator.
-        Args:
-            op(OpWrapper): Target operator..
-        Returns:
-            list<OpWrapper>: A list of operators.
-        """
-        ops = []
-        for p in self.ops():
-            for in_var in op.all_inputs():
-                if in_var in p.all_outputs():
-                    ops.append(p)
-        return ops
-
-    def next_ops(self, op):
-        """
-        Get all the next operators of target operator.
-        Args:
-            op(OpWrapper): Target operator..
-        Returns:
-            list<OpWrapper>: A list of operators.
-        """
-        ops = []
-        for p in self.ops():
-            for out_var in op.all_outputs():
-                if out_var in p.all_inputs():
-                    ops.append(p)
-        return ops
-
-    def get_param_by_op(self, op):
-        """
-        Get the parameters used by target operator.
-        """
-        assert isinstance(op, OpWrapper)
-        params = []
-        for var in op.all_inputs():
-            if isinstance(var._var, Parameter):
-                params.append(var)
-        assert len(params) > 0
-        return params
-
-    def numel_params(self):
-        """
-        Get the number of elements in all parameters.
-        """
-        ret = 0
-        for param in self.all_parameters():
-            ret += np.product(param.shape())
-        return ret
-
-    def get_optimize_graph(self, optimizer, place, scope, no_grad_var_names=[]):
-        """
-        Get a new graph for training by appending some backward operators and optimization operators.
-        Args:
-            optimizer: The optimzier used to generate training graph.
-            place: The place to run the graph.
-            scope: The scope used to run the graph. Some new variable will be added into this scope.
-            no_grad_var_names(list<str>): Names of variables that should be ignored while computing gradients. default: [].
-        Returns:
-            (GraphWrapper): The wrapper of new graph with backward ops and optimization ops. 
-        """
-        graph = self.clone()
-        startup_program = Program()
-        with program_guard(
-                main_program=graph.program, startup_program=startup_program):
-            target_name = None
-            if 'loss' in graph.out_nodes:
-                target_name = graph.out_nodes['loss']
-            elif 'cost' in graph.out_nodes:
-                target_name = graph.out_nodes['cost']
-            else:
-                return None
-            target = graph.var(target_name)._var
-            # The learning rate variable may be created in other program.
-            # Update information in optimizer to make
-            # learning rate variable being accessible in current program.
-            if isinstance(optimizer._learning_rate, Variable):
-                optimizer._learning_rate_map[
-                    graph.program] = optimizer._learning_rate
-            optimizer.minimize(target, no_grad_set=no_grad_var_names)
-
-        exe = Executor(place)
-        exe.run(program=startup_program, scope=scope)
-        return graph
-
-    def flops(self, only_conv=False):
-        """
-        Get the flops of current graph.
-        Args:
-            only_conv: Only calculating the conv layers. default: False.
-        Returns:
-            int: The flops of current graph.
-        """
-        flops = 0
-        for op in self.ops():
-            if op.type() in ['conv2d', 'depthwise_conv2d']:
-                filter_shape = op.inputs("Filter")[0].shape()
-                input_shape = op.inputs("Input")[0].shape()
-                output_shape = op.outputs("Output")[0].shape()
-                c_out, c_in, k_h, k_w = filter_shape
-                _, _, h_out, w_out = output_shape
-                groups = op.attr("groups")
-                kernel_ops = k_h * k_w * (c_in / groups)
-                if len(op.inputs("Bias")) > 0:
-                    with_bias = 1
-                else:
-                    with_bias = 0
-                flops += 2 * h_out * w_out * c_out * (kernel_ops + with_bias)
-            elif op.type() == 'pool2d' and not only_conv:
-                input_shape = op.inputs("X")[0].shape()
-                output_shape = op.outputs("Out")[0].shape()
-                _, c_out, h_out, w_out = output_shape
-                k_size = op.attr("ksize")
-                flops += h_out * w_out * c_out * (k_size[0]**2)
-
-            elif op.type() == 'mul' and not only_conv:
-                x_shape = list(op.inputs("X")[0].shape())
-                y_shape = op.inputs("Y")[0].shape()
-                if x_shape[0] == -1:
-                    x_shape[0] = 1
-                flops += 2 * x_shape[0] * x_shape[1] * y_shape[1]
-
-            elif op.type() in ['relu', 'sigmoid', 'batch_norm'
-                               ] and not only_conv:
-                input_shape = list(op.inputs("X")[0].shape())
-                if input_shape[0] == -1:
-                    input_shape[0] = 1
-                flops += np.product(input_shape)
-
-        return flops
-
-    def save_model(self, path, exe):
-        """
-        Save network and parameters into file which can be load by load_inference_model api.
-        Args:
-            path(str): The path to save the persistables.
-            exe(framework.Executor): The executor used to save the persistables.
-        """
-        out_vars = [
-            self.var(var_name)._var for var_name in self.out_nodes.values()
-        ]
-        in_vars = list(self.in_nodes.values())
-        assert (len(in_vars) > 0)
-        assert (len(out_vars) > 0)
-        io.save_inference_model(
-            path,
-            in_vars,
-            out_vars,
-            exe.exe,
-            model_filename="__model__",
-            params_filename="__params__",
-            main_program=self.program.clone(),
-            export_for_deployment=True)
-
-    def save_infer_model(self, path, exe, in_out, program_only=False):
-        """
-        Save network and parameters into file which can be load by load_inference_model api.
-        Args:
-            path(str): The path to save the persistables.
-            exe(framework.Executor): The executor used to save the persistables.
-            in_out(tuple|list): in_out[0] is a list of input nodes' names
-            and in_out[1] is a list of output nodes' names.
-            program_only(bool): Whether to save program only.
-        """
-        out_vars = [self.var(var_name)._var for var_name in in_out[1]]
-        in_vars = list(in_out[0])
-        assert (len(in_vars) > 0)
-        assert (len(out_vars) > 0)
-        io.save_inference_model(
-            path,
-            in_vars,
-            out_vars,
-            exe.exe,
-            model_filename="__model__.infer",
-            params_filename="__params__",
-            program_only=program_only,
-            main_program=self.program.clone(),
-            export_for_deployment=True)
-
-    def save_persistables(self, path, exe):
-        """
-        Save all the persistable variables into file.
-        Args:
-            path(str): The path to save the persistables.
-            exe(framework.Executor): The executor used to save the persistables.
-        """
-        # update persistables from program
-        for var in self.program.list_vars():
-            if var.persistable and var.name not in self.persistables:
-                self.persistables[var.name] = var
-        persistables = []
-        for var in self.persistables:
-            if 'reader' not in var and 'double_buffer' not in var and var not in self.teacher_persistables:
-                persistables.append(self.persistables[var])
-
-        io.save_vars(exe.exe, path, vars=persistables)
-
-    def load_persistables(self, path, exe):
-        """
-        Load the persistable variables from file.
-        Args:
-            path(str): The path to load the persistables.
-            exe(framework.Executor): The executor used to load the persistables.
-        """
-
-        def if_exist(var):
-            return os.path.exists(os.path.join(path, var.name))
-
-        persistables = []
-        for var in self.persistables:
-            if 'reader' not in var and 'double_buffer' not in var:
-                persistables.append(self.persistables[var])
-        io.load_vars(exe.exe, path, vars=persistables, predicate=if_exist)
-
-    def update_param_shape(self, scope):
-        """
-        Update the shape of parameters in the graph according to tensors in scope.
-        It is used after loading pruned parameters from file.
-        """
-        for param in self.all_parameters():
-            tensor_shape = np.array(scope.find_var(param.name()).get_tensor(
-            )).shape
-            param.set_shape(tensor_shape)
-
-    def infer_shape(self):
-        """
-        Update the groups of convolution layer according to current filters.
-        It is used after loading pruned parameters from file.
-        """
-        for op in self.ops():
-            if op.type() != 'conditional_block':
-                op._op.desc.infer_shape(op._op.block.desc)
-
-    def update_groups_of_conv(self):
-        for op in self.ops():
-            if op.type() == 'depthwise_conv2d' or op.type(
-            ) == 'depthwise_conv2d_grad':
-                op.set_attr('groups', op.inputs('Filter')[0].shape()[0])

python/paddle/fluid/contrib/slim/nas/__init__.py

-#   Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import light_nas_strategy
-from .light_nas_strategy import *
-from . import controller_server
-from .controller_server import *
-from . import search_agent
-from .search_agent import *
-from . import search_space
-from .search_space import *
-from . import lock
-from .lock import *
-
-__all__ = light_nas_strategy.__all__
-__all__ += controller_server.__all__
-__all__ += search_agent.__all__
-__all__ += search_space.__all__

python/paddle/fluid/contrib/slim/nas/controller_server.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-import socket
-from threading import Thread
-from ....log_helper import get_logger
-
-__all__ = ['ControllerServer']
-
-_logger = get_logger(
-    __name__,
-    logging.INFO,
-    fmt='ControllerServer-%(asctime)s-%(levelname)s: %(message)s')
-
-
-class ControllerServer(object):
-    """
-    The controller wrapper with a socket server to handle the request of search agentt.
-    """
-
-    def __init__(self,
-                 controller=None,
-                 address=('', 0),
-                 max_client_num=100,
-                 search_steps=None,
-                 key=None):
-        """
-        Args:
-            controller(slim.searcher.Controller): The controller used to generate tokens.
-            address(tuple): The address of current server binding with format (ip, port). Default: ('', 0).
-                            which means setting ip automatically
-            max_client_num(int): The maximum number of clients connecting to current server simultaneously. Default: 100.
-            search_steps(int): The total steps of searching. None means never stopping. Default: None 
-        """
-        self._controller = controller
-        self._address = address
-        self._max_client_num = max_client_num
-        self._search_steps = search_steps
-        self._closed = False
-        self._port = address[1]
-        self._ip = address[0]
-        self._key = key
-
-    def start(self):
-        self._socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self._socket_server.bind(self._address)
-        self._socket_server.listen(self._max_client_num)
-        self._port = self._socket_server.getsockname()[1]
-        self._ip = self._socket_server.getsockname()[0]
-        _logger.info("listen on: [{}:{}]".format(self._ip, self._port))
-        thread = Thread(target=self.run)
-        thread.start()
-        return str(thread)
-
-    def close(self):
-        """Close the server."""
-        self._closed = True
-
-    def port(self):
-        """Get the port."""
-        return self._port
-
-    def ip(self):
-        """Get the ip."""
-        return self._ip
-
-    def run(self):
-        _logger.info("Controller Server run...")
-        while ((self._search_steps is None) or
-               (self._controller._iter <
-                (self._search_steps))) and not self._closed:
-            conn, addr = self._socket_server.accept()
-            message = conn.recv(1024).decode()
-            if message.strip("\n") == "next_tokens":
-                tokens = self._controller.next_tokens()
-                tokens = ",".join([str(token) for token in tokens])
-                conn.send(tokens.encode())
-            else:
-                _logger.info("recv message from {}: [{}]".format(addr, message))
-                messages = message.strip('\n').split("\t")
-                if (len(messages) < 3) or (messages[0] != self._key):
-                    _logger.info("recv noise from {}: [{}]".format(addr,
-                                                                   message))
-                    continue
-                tokens = messages[1]
-                reward = messages[2]
-                tokens = [int(token) for token in tokens.split(",")]
-                self._controller.update(tokens, float(reward))
-                tokens = self._controller.next_tokens()
-                tokens = ",".join([str(token) for token in tokens])
-                conn.send(tokens.encode())
-                _logger.info("send message to {}: [{}]".format(addr, tokens))
-            conn.close()
-        self._socket_server.close()
-        _logger.info("server closed!")

python/paddle/fluid/contrib/slim/nas/light_nas_strategy.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from ..core.strategy import Strategy
-from ..graph import GraphWrapper
-from .controller_server import ControllerServer
-from .search_agent import SearchAgent
-from ....executor import Executor
-from ....log_helper import get_logger
-import re
-import logging
-import functools
-import socket
-from .lock import lock, unlock
-
-__all__ = ['LightNASStrategy']
-
-_logger = get_logger(
-    __name__,
-    logging.INFO,
-    fmt='LightNASStrategy-%(asctime)s-%(levelname)s: %(message)s')
-
-
-class LightNASStrategy(Strategy):
-    """
-    Light-NAS search strategy.
-    """
-
-    def __init__(self,
-                 controller=None,
-                 end_epoch=1000,
-                 target_flops=629145600,
-                 target_latency=0,
-                 retrain_epoch=1,
-                 metric_name='top1_acc',
-                 server_ip=None,
-                 server_port=0,
-                 is_server=False,
-                 max_client_num=100,
-                 search_steps=None,
-                 key="light-nas"):
-        """
-        Args:
-            controller(searcher.Controller): The searching controller. Default: None.
-            end_epoch(int): The 'on_epoch_end' function will be called in end_epoch. Default: 0
-            target_flops(int): The constraint of FLOPS.
-            target_latency(float): The constraint of latency.
-            retrain_epoch(int): The number of training epochs before evaluating structure generated by controller. Default: 1.
-            metric_name(str): The metric used to evaluate the model.
-                         It should be one of keys in out_nodes of graph wrapper. Default: 'top1_acc'
-            server_ip(str): The ip that controller server listens on. None means getting the ip automatically. Default: None.
-            server_port(int): The port that controller server listens on. 0 means getting usable port automatically. Default: 0.
-            is_server(bool): Whether current host is controller server. Default: False.
-            max_client_num(int): The maximum number of clients that connect to controller server concurrently. Default: 100.
-            search_steps(int): The total steps of searching. Default: None.
-            key(str): The key used to identify legal agent for controller server. Default: "light-nas"
-        """
-        self.start_epoch = 0
-        self.end_epoch = end_epoch
-        self._max_flops = target_flops
-        self._max_latency = target_latency
-        self._metric_name = metric_name
-        self._controller = controller
-        self._retrain_epoch = 0
-        self._server_ip = server_ip
-        self._server_port = server_port
-        self._is_server = is_server
-        self._retrain_epoch = retrain_epoch
-        self._search_steps = search_steps
-        self._max_client_num = max_client_num
-        self._max_try_times = 100
-        self._key = key
-
-        if self._server_ip is None:
-            self._server_ip = self._get_host_ip()
-
-    def _get_host_ip(self):
-        return socket.gethostbyname(socket.gethostname())
-
-    def on_compression_begin(self, context):
-        self._current_tokens = context.search_space.init_tokens()
-        self._controller.reset(context.search_space.range_table(),
-                               self._current_tokens, None)
-
-        # create controller server
-        if self._is_server:
-            open("./slim_LightNASStrategy_controller_server.socket",
-                 'a').close()
-            socket_file = open(
-                "./slim_LightNASStrategy_controller_server.socket", 'r+')
-            lock(socket_file)
-            tid = socket_file.readline()
-            if tid == '':
-                _logger.info("start controller server...")
-                self._server = ControllerServer(
-                    controller=self._controller,
-                    address=(self._server_ip, self._server_port),
-                    max_client_num=self._max_client_num,
-                    search_steps=self._search_steps,
-                    key=self._key)
-                tid = self._server.start()
-                self._server_port = self._server.port()
-                socket_file.write(tid)
-                _logger.info("started controller server...")
-            unlock(socket_file)
-            socket_file.close()
-        _logger.info("self._server_ip: {}; self._server_port: {}".format(
-            self._server_ip, self._server_port))
-        # create client
-        self._search_agent = SearchAgent(
-            self._server_ip, self._server_port, key=self._key)
-
-    def __getstate__(self):
-        """Socket can't be pickled."""
-        d = {}
-        for key in self.__dict__:
-            if key not in ["_search_agent", "_server"]:
-                d[key] = self.__dict__[key]
-        return d
-
-    def on_epoch_begin(self, context):
-        if context.epoch_id >= self.start_epoch and context.epoch_id <= self.end_epoch and (
-                self._retrain_epoch == 0 or
-            (context.epoch_id - self.start_epoch) % self._retrain_epoch == 0):
-            _logger.info("light nas strategy on_epoch_begin")
-            min_flops = -1
-            for _ in range(self._max_try_times):
-                startup_p, train_p, test_p, _, _, train_reader, test_reader = context.search_space.create_net(
-                    self._current_tokens)
-                context.eval_graph.program = test_p
-                flops = context.eval_graph.flops()
-                if min_flops == -1:
-                    min_flops = flops
-                    min_tokens = self._current_tokens[:]
-                else:
-                    if flops < min_flops:
-                        min_tokens = self._current_tokens[:]
-                if self._max_latency > 0:
-                    latency = context.search_space.get_model_latency(test_p)
-                    _logger.info("try [{}] with latency {} flops {}".format(
-                        self._current_tokens, latency, flops))
-                else:
-                    _logger.info("try [{}] with flops {}".format(
-                        self._current_tokens, flops))
-                if flops > self._max_flops or (self._max_latency > 0 and
-                                               latency > self._max_latency):
-                    self._current_tokens = self._controller.next_tokens(
-                        min_tokens)
-                else:
-                    break
-
-            context.train_reader = train_reader
-            context.eval_reader = test_reader
-
-            exe = Executor(context.place)
-            exe.run(startup_p)
-
-            context.optimize_graph.program = train_p
-            context.optimize_graph.compile()
-
-            context.skip_training = (self._retrain_epoch == 0)
-
-    def on_epoch_end(self, context):
-        if context.epoch_id >= self.start_epoch and context.epoch_id < self.end_epoch and (
-                self._retrain_epoch == 0 or
-            (context.epoch_id - self.start_epoch + 1
-             ) % self._retrain_epoch == 0):
-
-            self._current_reward = context.eval_results[self._metric_name][-1]
-            flops = context.eval_graph.flops()
-            if flops > self._max_flops:
-                self._current_reward = 0.0
-            if self._max_latency > 0:
-                test_p = context.search_space.create_net(self._current_tokens)[
-                    2]
-                latency = context.search_space.get_model_latency(test_p)
-                if latency > self._max_latency:
-                    self._current_reward = 0.0
-                _logger.info("reward: {}; latency: {}; flops: {}; tokens: {}".
-                             format(self._current_reward, latency, flops,
-                                    self._current_tokens))
-            else:
-                _logger.info("reward: {}; flops: {}; tokens: {}".format(
-                    self._current_reward, flops, self._current_tokens))
-            self._current_tokens = self._search_agent.update(
-                self._current_tokens, self._current_reward)

python/paddle/fluid/contrib/slim/nas/lock.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-__All__ = ['lock', 'unlock']
-if os.name == 'nt':
-
-    def lock(file):
-        raise NotImplementedError('Windows is not supported.')
-
-    def unlock(file):
-        raise NotImplementedError('Windows is not supported.')
-
-elif os.name == 'posix':
-    from fcntl import flock, LOCK_EX, LOCK_UN
-
-    def lock(file):
-        """Lock the file in local file system."""
-        flock(file.fileno(), LOCK_EX)
-
-    def unlock(file):
-        """Unlock the file in local file system."""
-        flock(file.fileno(), LOCK_UN)
-else:
-    raise RuntimeError("File Locker only support NT and Posix platforms!")

python/paddle/fluid/contrib/slim/nas/search_agent.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-import socket
-from ....log_helper import get_logger
-
-__all__ = ['SearchAgent']
-
-_logger = get_logger(
-    __name__, logging.INFO, fmt='%(asctime)s-%(levelname)s: %(message)s')
-
-
-class SearchAgent(object):
-    """
-    Search agent.
-    """
-
-    def __init__(self, server_ip=None, server_port=None, key=None):
-        """
-        Args:
-            server_ip(str): The ip that controller server listens on. None means getting the ip automatically. Default: None.
-            server_port(int): The port that controller server listens on. 0 means getting usable port automatically. Default: 0.
-            key(str): The key used to identify legal agent for controller server. Default: "light-nas"
-        """
-        self.server_ip = server_ip
-        self.server_port = server_port
-        self.socket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self._key = key
-
-    def update(self, tokens, reward):
-        """
-        Update the controller according to latest tokens and reward.
-        Args:
-            tokens(list<int>): The tokens generated in last step.
-            reward(float): The reward of tokens.
-        """
-        socket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        socket_client.connect((self.server_ip, self.server_port))
-        tokens = ",".join([str(token) for token in tokens])
-        socket_client.send("{}\t{}\t{}".format(self._key, tokens, reward)
-                           .encode())
-        tokens = socket_client.recv(1024).decode()
-        tokens = [int(token) for token in tokens.strip("\n").split(",")]
-        return tokens
-
-    def next_tokens(self):
-        """
-        Get next tokens.
-        """
-        socket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        socket_client.connect((self.server_ip, self.server_port))
-        socket_client.send("next_tokens".encode())
-        tokens = socket_client.recv(1024).decode()
-        tokens = [int(token) for token in tokens.strip("\n").split(",")]
-        return tokens

python/paddle/fluid/contrib/slim/nas/search_space.py

-#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The search space used to search neural architecture"""
-
-__all__ = ['SearchSpace']
-
-
-class SearchSpace(object):
-    """Controller for Neural Architecture Search.
-    """
-
-    def __init__(self, *args, **kwargs):
-        pass
-
-    def init_tokens(self):
-        """Get init tokens in search space.
-        """
-        raise NotImplementedError('Abstract method.')
-
-    def range_table(self):
-        """Get range table of current search space.
-        """
-        raise NotImplementedError('Abstract method.')
-
-    def create_net(self, tokens):
-        """Create networks for training and evaluation according to tokens.
-        Args:
-            tokens(list<int>): The tokens which represent a network.
-        Return:
-            (tuple): startup_program, train_program, evaluation_program, train_metrics, test_metrics
-        """
-        raise NotImplementedError('Abstract method.')
-
-    def get_model_latency(self, program):
-        """Get model latency according to program.
-        Args:
-            program(Program): The program to get latency.
-        Return:
-            (float): model latency.
-        """
-        raise NotImplementedError('Abstract method.')

python/paddle/fluid/contrib/slim/prune/__init__.py

-#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import pruner
-from .pruner import *
-from . import prune_strategy
-from .prune_strategy import *
-from . import auto_prune_strategy
-from .auto_prune_strategy import *
-
-__all__ = pruner.__all__
-__all__ += prune_strategy.__all__
-__all__ += auto_prune_strategy.__all__

python/paddle/fluid/contrib/slim/prune/auto_prune_strategy.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .prune_strategy import PruneStrategy
-import re
-import logging
-import functools
-import copy
-from ....log_helper import get_logger
-
-__all__ = ['AutoPruneStrategy']
-
-_logger = get_logger(
-    __name__, logging.INFO, fmt='%(asctime)s-%(levelname)s: %(message)s')
-
-
-class AutoPruneStrategy(PruneStrategy):
-    """
-    Automatic pruning strategy.
-    """
-
-    def __init__(self,
-                 pruner=None,
-                 controller=None,
-                 start_epoch=0,
-                 end_epoch=10,
-                 min_ratio=0.5,
-                 max_ratio=0.7,
-                 metric_name='top1_acc',
-                 pruned_params='conv.*_weights',
-                 retrain_epoch=0,
-                 uniform_range=None,
-                 init_tokens=None):
-        """
-        Args:
-            pruner(slim.Pruner): The pruner used to prune the parameters. Default: None.
-            controller(searcher.Controller): The searching controller. Default: None.
-            start_epoch(int): The 'on_epoch_begin' function will be called in start_epoch. Default: 0
-            end_epoch(int): The 'on_epoch_end' function will be called in end_epoch. Default: 0
-            min_ratio(float): The maximum pruned ratio. Default: 0.7
-            max_ratio(float): The minimum pruned ratio. Default: 0.5
-            metric_name(str): The metric used to evaluate the model.
-                         It should be one of keys in out_nodes of graph wrapper. Default: 'top1_acc'
-            pruned_params(str): The pattern str to match the parameter names to be pruned. Default: 'conv.*_weights'
-            retrain_epoch(int): The training epochs in each seaching step. Default: 0
-            uniform_range(int): The token range in each position of tokens generated by controller. None means getting the range automatically. Default: None.
-            init_tokens(list<int>): The initial tokens. None means getting the initial tokens automatically. Default: None.
-        """
-        super(AutoPruneStrategy, self).__init__(pruner, start_epoch, end_epoch,
-                                                0.0, metric_name, pruned_params)
-        self._max_ratio = max_ratio
-        self._min_ratio = min_ratio
-        self._controller = controller
-        self._metric_name = metric_name
-        self._pruned_param_names = []
-        self._retrain_epoch = retrain_epoch
-        self._uniform_range = uniform_range
-        self._init_tokens = init_tokens
-        self._current_tokens = None
-
-    def on_compression_begin(self, context):
-        """
-        Prepare some information for searching strategy.
-        step 1: Find all the parameters to be pruned.
-        step 2: Get initial tokens and setup controller.
-        """
-        pruned_params = []
-        for param in context.eval_graph.all_parameters():
-            if re.match(self.pruned_params, param.name()):
-                self._pruned_param_names.append(param.name())
-
-        if self._init_tokens is not None:
-            self._current_tokens = self._init_tokens
-        else:
-            self._current_tokens = self._get_init_tokens(context)
-
-        if self._uniform_range is not None:
-            self._range_table = [round(self._uniform_range, 2) / 0.01] * len(
-                self._pruned_param_names)
-        else:
-            self._range_table = copy.deepcopy(self._current_tokens)
-        _logger.info('init tokens: {}'.format(self._current_tokens))
-        _logger.info("range_table: {}".format(self._range_table))
-        constrain_func = functools.partial(
-            self._constrain_func, context=context)
-
-        self._controller.reset(self._range_table, self._current_tokens,
-                               constrain_func)
-
-    def _constrain_func(self, tokens, context=None):
-        """Check whether the tokens meet constraint."""
-        ori_flops = context.eval_graph.flops()
-        ratios = self._tokens_to_ratios(tokens)
-        params = self._pruned_param_names
-        param_shape_backup = {}
-        self._prune_parameters(
-            context.eval_graph,
-            context.scope,
-            params,
-            ratios,
-            context.place,
-            only_graph=True,
-            param_shape_backup=param_shape_backup)
-        context.eval_graph.update_groups_of_conv()
-        flops = context.eval_graph.flops()
-        for param in param_shape_backup.keys():
-            context.eval_graph.var(param).set_shape(param_shape_backup[param])
-        flops_ratio = (1 - float(flops) / ori_flops)
-        if flops_ratio >= self._min_ratio and flops_ratio <= self._max_ratio:
-            _logger.info("Success try [{}]; flops: -{}".format(tokens,
-                                                               flops_ratio))
-            return True
-        else:
-            _logger.info("Failed try [{}]; flops: -{}".format(tokens,
-                                                              flops_ratio))
-            return False
-
-    def _get_init_tokens(self, context):
-        """Get initial tokens.
-        """
-        ratios = self._get_uniform_ratios(context)
-        _logger.info('Get init ratios: {}'.format(
-            [round(r, 2) for r in ratios]))
-        return self._ratios_to_tokens(ratios)
-
-    def _ratios_to_tokens(self, ratios):
-        """Convert pruned ratios to tokens.
-        """
-        return [int(ratio / 0.01) for ratio in ratios]
-
-    def _tokens_to_ratios(self, tokens):
-        """Convert tokens to pruned ratios.
-        """
-        return [token * 0.01 for token in tokens]
-
-    def _get_uniform_ratios(self, context):
-        """
-        Search a group of uniform ratios.
-        """
-        min_ratio = 0.
-        max_ratio = 1.
-        target = (self._min_ratio + self._max_ratio) / 2
-        flops = context.eval_graph.flops()
-        model_size = context.eval_graph.numel_params()
-        ratios = None
-        while min_ratio < max_ratio:
-            ratio = (max_ratio + min_ratio) / 2
-            ratios = [ratio] * len(self._pruned_param_names)
-            param_shape_backup = {}
-            self._prune_parameters(
-                context.eval_graph,
-                context.scope,
-                self._pruned_param_names,
-                ratios,
-                context.place,
-                only_graph=True,
-                param_shape_backup=param_shape_backup)
-
-            pruned_flops = 1 - (float(context.eval_graph.flops()) / flops)
-            pruned_size = 1 - (float(context.eval_graph.numel_params()) /
-                               model_size)
-            for param in param_shape_backup.keys():
-                context.eval_graph.var(param).set_shape(param_shape_backup[
-                    param])
-
-            if abs(pruned_flops - target) < 1e-2:
-                break
-            if pruned_flops > target:
-                max_ratio = ratio
-            else:
-                min_ratio = ratio
-        _logger.info('Get ratios: {}'.format([round(r, 2) for r in ratios]))
-        return ratios
-
-    def on_epoch_begin(self, context):
-        """
-        step 1: Get a new tokens from controller.
-        step 2: Pruning eval_graph and optimize_program by tokens
-        """
-        if context.epoch_id >= self.start_epoch and context.epoch_id <= self.end_epoch and (
-                self._retrain_epoch == 0 or
-            (context.epoch_id - self.start_epoch) % self._retrain_epoch == 0):
-            _logger.info("on_epoch_begin")
-            params = self._pruned_param_names
-            ratios = self._tokens_to_ratios(self._current_tokens)
-
-            self._param_shape_backup = {}
-            self._param_backup = {}
-            self._prune_parameters(
-                context.optimize_graph,
-                context.scope,
-                params,
-                ratios,
-                context.place,
-                param_backup=self._param_backup,
-                param_shape_backup=self._param_shape_backup)
-            self._prune_graph(context.eval_graph, context.optimize_graph)
-            context.optimize_graph.update_groups_of_conv()
-            context.eval_graph.update_groups_of_conv()
-            context.optimize_graph.compile(
-                mem_opt=False)  # to update the compiled program
-            context.skip_training = (self._retrain_epoch == 0)
-
-    def on_epoch_end(self, context):
-        """
-        step 1: Get reward of current tokens and update controller.
-        step 2: Restore eval_graph and optimize_graph
-        """
-        if context.epoch_id >= self.start_epoch and context.epoch_id < self.end_epoch and (
-                self._retrain_epoch == 0 or
-            (context.epoch_id - self.start_epoch + 1
-             ) % self._retrain_epoch == 0):
-            _logger.info("on_epoch_end")
-            reward = context.eval_results[self._metric_name][-1]
-            self._controller.update(self._current_tokens, reward)
-
-            self._current_tokens = self._controller.next_tokens()
-            # restore pruned parameters
-            for param_name in self._param_backup.keys():
-                param_t = context.scope.find_var(param_name).get_tensor()
-                param_t.set(self._param_backup[param_name], context.place)
-            self._param_backup = {}
-            # restore shape of parameters
-            for param in self._param_shape_backup.keys():
-                context.optimize_graph.var(param).set_shape(
-                    self._param_shape_backup[param])
-            self._param_shape_backup = {}
-            self._prune_graph(context.eval_graph, context.optimize_graph)
-
-            context.optimize_graph.update_groups_of_conv()
-            context.eval_graph.update_groups_of_conv()
-            context.optimize_graph.compile(
-                mem_opt=False)  # to update the compiled program
-
-        elif context.epoch_id == self.end_epoch:  # restore graph for final training
-            # restore pruned parameters
-            for param_name in self._param_backup.keys():
-                param_t = context.scope.find_var(param_name).get_tensor()
-                param_t.set(self.param_backup[param_name], context.place)
-            # restore shape of parameters
-            for param in self._param_shape_backup.keys():
-                context.eval_graph.var(param).set_shape(
-                    self._param_shape_backup[param])
-                context.optimize_graph.var(param).set_shape(
-                    self._param_shape_backup[param])
-
-            context.optimize_graph.update_groups_of_conv()
-            context.eval_graph.update_groups_of_conv()
-
-            params, ratios = self._get_prune_ratios(
-                self._controller._best_tokens)
-            self._prune_parameters(context.optimize_graph, context.scope,
-                                   params, ratios, context.place)
-
-            self._prune_graph(context.eval_graph, context.optimize_graph)
-            context.optimize_graph.update_groups_of_conv()
-            context.eval_graph.update_groups_of_conv()
-            context.optimize_graph.compile(
-                mem_opt=True)  # to update the compiled program
-
-            context.skip_training = False

python/paddle/fluid/contrib/slim/prune/pruner.py

-# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import numpy as np
-import collections
-from .... import layers
-
-__all__ = ['Pruner', 'StructurePruner']
-
-
-class Pruner(object):
-    """
-    Base class of all pruners.
-    """
-
-    def __init__(self):
-        pass
-
-    def prune(self, param):
-        pass
-
-
-class StructurePruner(Pruner):
-    """
-    Pruner used to pruning parameters by groups.
-    """
-
-    def __init__(self, pruning_axis, criterions):
-        """
-        Args:
-            pruning_axis(dict): The key is the name of parameter to be pruned,
-                                '*' means all the parameters.
-                                The value is the axis to be used. Given a parameter
-                                with shape [3, 4], the result of pruning 50% on aixs 1
-                                is a parameter with shape [3, 2].
-            criterions(dict): The key is the name of parameter to be pruned,
-                              '*' means all the parameters.
-                              The value is the criterion used to sort groups for pruning.
-                              It only supports 'l1_norm' currently.
-        """
-        self.pruning_axis = pruning_axis
-        self.criterions = criterions
-
-    def cal_pruned_idx(self, name, param, ratio, axis=None):
-        """
-        Calculate the index to be pruned on axis by given pruning ratio.
-        Args:
-            name(str): The name of parameter to be pruned.
-            param(np.array): The data of parameter to be pruned.
-            ratio(float): The ratio to be pruned.
-            axis(int): The axis to be used for pruning given parameter.
-                       If it is None, the value in self.pruning_axis will be used.
-                       default: None.
-        Returns:
-            list<int>: The indexes to be pruned on axis.
-        """
-        criterion = self.criterions[
-            name] if name in self.criterions else self.criterions['*']
-        if axis is None:
-            assert self.pruning_axis is not None, "pruning_axis should set if axis is None."
-            axis = self.pruning_axis[
-                name] if name in self.pruning_axis else self.pruning_axis['*']
-        prune_num = int(round(param.shape[axis] * ratio))
-        reduce_dims = [i for i in range(len(param.shape)) if i != axis]
-        if criterion == 'l1_norm':
-            criterions = np.sum(np.abs(param), axis=tuple(reduce_dims))
-        pruned_idx = criterions.argsort()[:prune_num]
-        return pruned_idx
-
-    def prune_tensor(self, tensor, pruned_idx, pruned_axis, lazy=False):
-        """
-        Pruning a array by indexes on given axis.
-        Args:
-            tensor(numpy.array): The target array to be pruned.
-            pruned_idx(list<int>): The indexes to be pruned.
-            pruned_axis(int): The axis of given array to be pruned on. 
-            lazy(bool): True means setting the pruned elements to zero.
-                        False means remove the pruned elements from memory.
-                        default: False.
-        Returns:
-            numpy.array: The pruned array.
-        """
-        mask = np.zeros(tensor.shape[pruned_axis], dtype=bool)
-        mask[pruned_idx] = True
-
-        def func(data):
-            return data[~mask]
-
-        def lazy_func(data):
-            data[mask] = 0
-            return data
-
-        if lazy:
-            return np.apply_along_axis(lazy_func, pruned_axis, tensor)
-        else:
-            return np.apply_along_axis(func, pruned_axis, tensor)

python/paddle/fluid/contrib/slim/quantization/__init__.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import print_function
-
-from . import quantization_pass
-from .quantization_pass import *
-from . import quantization_strategy
-from .quantization_strategy import *
-from . import mkldnn_post_training_strategy
-from .mkldnn_post_training_strategy import *
-from . import quantization_mkldnn_pass
-from .quantization_mkldnn_pass import *
-from . import post_training_quantization
-from .post_training_quantization import *
-
-__all__ = quantization_pass.__all__ + quantization_strategy.__all__
-__all__ += mkldnn_post_training_strategy.__all__
-__all__ += quantization_mkldnn_pass.__all__
-__all__ += post_training_quantization.__all__

python/paddle/fluid/contrib/slim/quantization/mkldnn_post_training_strategy.py

-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import logging
-import six
-import numpy as np
-from .... import core
-from ..core.strategy import Strategy
-from ....log_helper import get_logger
-
-__all__ = ['MKLDNNPostTrainingQuantStrategy']
-
-_logger = get_logger(
-    __name__, logging.INFO, fmt='%(asctime)s-%(levelname)s: %(message)s')
-
-
-class MKLDNNPostTrainingQuantStrategy(Strategy):
-    """
-    The strategy for MKL-DNN Post Training quantization strategy.
-    """
-
-    def __init__(self,
-                 int8_model_save_path=None,
-                 fp32_model_path=None,
-                 cpu_math_library_num_threads=1):
-        """
-        Args:
-            int8_model_save_path(str): int8_model_save_path is used to save an int8 ProgramDesc
-                        with fp32 weights which is used for MKL-DNN int8 inference. For post training quantization,
-                        MKLDNNPostTrainingQuantStrategy only supports converting a fp32 ProgramDesc
-                        with fp32 weights to an int8 ProgramDesc with fp32 weights now. The saved
-                        int8 ProgramDesc with fp32 weights only can be executed with MKL-DNN enabled.
-                        None means it doesn't save int8 ProgramDesc with fp32 weights. default: None.
-            fp32_model_path(str): fp32_model_path is used to load an original fp32 ProgramDesc with fp32 weights.
-                        None means it doesn't have a fp32 ProgramDesc with fp32 weights. default: None.
-            cpu_math_library_num_threads(int): The number of cpu math library threads which is used on
-                        MKLDNNPostTrainingQuantStrategy. 1 means it only uses one cpu math library
-                        thread. default: 1
-        """
-
-        super(MKLDNNPostTrainingQuantStrategy, self).__init__(0, 0)
-        self.int8_model_save_path = int8_model_save_path
-        if fp32_model_path is None:
-            raise Exception("fp32_model_path is None")
-        self.fp32_model_path = fp32_model_path
-        self.cpu_math_library_num_threads = cpu_math_library_num_threads
-
-    def on_compression_begin(self, context):
-        """
-        Prepare the data and quantify the model
-        """
-
-        super(MKLDNNPostTrainingQuantStrategy,
-              self).on_compression_begin(context)
-        _logger.info('InferQuantStrategy::on_compression_begin')
-
-        # Prepare the Analysis Config
-        infer_config = core.AnalysisConfig("AnalysisConfig")
-        infer_config.switch_ir_optim(True)
-        infer_config.disable_gpu()
-        infer_config.set_model(self.fp32_model_path)
-        infer_config.enable_mkldnn()
-        infer_config.set_cpu_math_library_num_threads(
-            self.cpu_math_library_num_threads)
-
-        # Prepare the data for calculating the quantization scales
-        warmup_reader = context.eval_reader()
-        if six.PY2:
-            data = warmup_reader.next()
-
-        if six.PY3:
-            data = warmup_reader.__next__()
-
-        num_images = len(data)
-        image_data = [img.tolist() for (img, _) in data]
-        image_data = np.array(image_data).astype("float32").reshape(
-            [num_images, ] + list(data[0][0].shape))
-        image_data = image_data.ravel()
-        images = core.PaddleTensor(image_data, "x")
-        images.shape = [num_images, ] + list(data[0][0].shape)
-
-        label_data = [label for (_, label) in data]
-        labels = core.PaddleTensor(
-            np.array(label_data).astype("int64").reshape([num_images, 1]), "y")
-
-        warmup_data = [images, labels]
-
-        # Enable the INT8 Quantization
-        infer_config.enable_quantizer()
-        infer_config.quantizer_config().set_quant_data(warmup_data)
-        infer_config.quantizer_config().set_quant_batch_size(num_images)
-
-        # Run INT8 MKL-DNN Quantization
-        predictor = core.create_paddle_predictor(infer_config)
-        if self.int8_model_save_path:
-            if not os.path.exists(self.int8_model_save_path):
-                os.makedirs(self.int8_model_save_path)
-            predictor.SaveOptimModel(self.int8_model_save_path)
-
-        _logger.info(
-            'Finish MKLDNNPostTrainingQuantStrategy::on_compresseion_begin')

python/paddle/fluid/contrib/slim/searcher/__init__.py

-#   Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import controller
-from .controller import *
-
-__all__ = controller.__all__