如何保存对象fis_01并用于其他程序，例如GA

Question

在下面的程序中，我想将fis_01保存在文件中，并使用另一个应用程序

Error received: TypeError: can't pickle _thread.RLock objects

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import time
import pandas as pd
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
import pickle
class ANFIS:
    def __init__(self, n_inputs, n_rules, learning_rate=1e-2):
        self.n = n_inputs
        self.m = n_rules
        self.inputs = tf.placeholder(tf.float32, shape=(None, n_inputs))  **# Input**
        self.targets = tf.placeholder(tf.float32, shape=None)  **# Desired output**
        mu = tf.get_variable("mu", [n_rules * n_inputs],
                             initializer=tf.random_normal_initializer(0, 1))  # Means of Gaussian MFS
        sigma = tf.get_variable("sigma", [n_rules * n_inputs],
                                initializer=tf.random_normal_initializer(0, 1))  # Standard deviations of Gaussian MFS
        y = tf.get_variable("y", [1, n_rules], initializer=tf.random_normal_initializer(0, 1))  # Sequent centers

        self.params = tf.trainable_variables()

        self.rul = tf.reduce_prod(
            tf.reshape(tf.exp(-0.5 * tf.square(tf.subtract(tf.tile(self.inputs, (1, n_rules)), mu)) / tf.square(sigma)),
                       (-1, n_rules, n_inputs)), axis=2)  
        **# Rule activations**
        **# Fuzzy base expansion function:**
        num = tf.reduce_sum(tf.multiply(self.rul, y), axis=1)
        den = tf.clip_by_value(tf.reduce_sum(self.rul, axis=1), 1e-12, 1e12)
        self.out = tf.divide(num, den)

        self.loss = tf.losses.huber_loss(self.targets, self.out)
      **# Loss function computation**
        # Other loss functions for regression, uncomment to try them:
        # loss = tf.sqrt(tf.losses.mean_squared_error(target, out))
        # loss = tf.losses.absolute_difference(target, out)
        self.optimize = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(self.loss)  # Optimization step
        # Other optimizers, uncomment to try them:
        # self.optimize = tf.train.RMSPropOptimizer(learning_rate=learning_rate).minimize(self.loss)
        # self.optimize = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(self.loss)
        self.init_variables = tf.global_variables_initializer()  # Variable initializer

    def infer(self, sess, x, targets=None):
        if targets is None:
            return sess.run(self.out, feed_dict={self.inputs: x})
        else:
            return sess.run([self.out, self.loss], feed_dict= 
        {self.inputs: x, self.targets: targets})

    def train(self, sess, x, targets):
        yp, l, _ = sess.run([self.out, self.loss, self.optimize], feed_dict={self.inputs: x, self.targets: targets})
        return l, yp
    def plotmfs(self, sess):
        mus = sess.run(self.params[0])
        mus = np.reshape(mus, (self.m, self.n))
        sigmas = sess.run(self.params[1])
        sigmas = np.reshape(sigmas, (self.m, self.n))
        y = sess.run(self.params[2])
        xn = np.linspace(-1.5, 1.5, 1000)
        for r in range(self.m):
            if r % 4 == 0:
                plt.figure(figsize=(11, 6), dpi=80)
            plt.subplot(2, 2, (r % 4) + 1)
            ax = plt.subplot(2, 2, (r % 4) + 1)
            ax.set_title("Rule %d, sequent center: %f" % ((r + 1), y[0, 
            r]))
            for i in range(self.n):
                plt.plot(xn, np.exp(-0.5 * ((xn - mus[r, i]) ** 2) / 
                (sigmas[r, i] ** 2)))
tf.reset_default_graph()
ts=pd.read_csv('data for modelling by python 1398.02.12.csv')
input_data=np.array(ts)
num_rand=np.random.permutation(input_data.shape[0])
input_rand_data=input_data[num_rand,:]
X_scaling_01=preprocessing.scale(input_data[:,np.array([0,1])]) 
X_scaling_02=preprocessing.scale(input_data[:,np.array([2,3])]) 
target=input_data[:,-1]
trnData, chkData, trnLbls, chkLbls = train_test_split(X_scaling_01, 
target, test_size=0.2, random_state=0)
# Generate dataset
D = X_scaling_01.shape[1]
fis_01=[]
**# ANFIS params and Tensorflow graph initialization**
def modelling(trnData,trnLbls,chkData,chkLbls,m):
    alpha = 0.001  
**# learning rate**
    fis=ANFIS(n_inputs=D, n_rules=m, learning_rate=alpha)
    **# Training**
    num_epochs = 20
    **# Initialize session to make computations on the Tensorflow graph**
    with tf.Session() as sess:
        **# Initialize model parameters**
        sess.run(fis.init_variables)
        trn_costs = []
        val_costs = []
        time_start = time.time()
        for epoch in range(num_epochs):
            **#  Run an update step**
            trn_loss, trn_pred = fis.train(sess, trnData, trnLbls)
            **# Evaluate on validation set**
            val_pred, val_loss = fis.infer(sess, chkData, chkLbls)
            if epoch % 10 == 0:
                print("Train cost after epoch %i: %f" % (epoch, 
                trn_loss))
            if epoch == num_epochs - 1:
                time_end = time.time()
                print("Elapsed time: %f" % (time_end - time_start))
                print("Validation loss: %f" % val_loss)
                **# Plot real vs. predicted**
                pred = np.vstack((np.expand_dims(trn_pred, 1), 
                np.expand_dims(val_pred, 1)))
                plt.figure(1)
                plt.plot(pred)
            trn_costs.append(trn_loss)
            val_costs.append(val_loss)
**# Plot the cost over epochs**
        plt.figure(2)
        plt.subplot(2, 1, 1)
        plt.plot(np.squeeze(trn_costs))
        plt.title("Training loss, Learning rate =" + str(alpha))
        plt.subplot(2, 1, 2)
        plt.plot(np.squeeze(val_costs))
        plt.title("Validation loss, Learning rate =" + str(alpha))
        plt.ylabel('Cost')
        plt.xlabel('Epochs')
        **# Plot resulting membership functions**
        fis.plotmfs(sess)
        plt.show()
    error=sum((val_pred-chkLbls)**2)
    return error, val_pred,val_loss,trn_loss, trn_pred,fis
number_of_replication=2
error_rep=np.zeros(number_of_replication)
val_loss=np.zeros(number_of_replication)
trn_loss=np.zeros(number_of_replication)
m = 16
[E,tp,vls,trls,trp,fis_01]=modelling(trnData,trnLbls,chkData,chkLbls,m)
pickle.dump(fis_01,open('structure_fis.pkl','w'))
tf.reset_default_graph()
R_train_01=100*(np.corrcoef(trnLbls,tp)[0,1])**2