cancer_file2=pd.read_csv(cancer_train_file)
cancer_file3=pd.read_csv(cancer_test_file)

diagnosis_mapping={'M':0,'B':1}
cancer_file2['diagnosis']=cancer_file2['diagnosis'].map(diagnosis_mapping)
cancer_file3['diagnosis']=cancer_file3['diagnosis'].map(diagnosis_mapping)

list1 = ['id','diagnosis'] 
cancer_file2_y = cancer_file2.diagnosis 
cancer_file2_x = cancer_file2.drop(list1,axis = 1 ) 
cancer_file3_y = cancer_file3.diagnosis 
cancer_file3_x = cancer_file3.drop(list1,axis = 1 )

def Encoder(qubits):
 prg = PRGenerator('alpha')
 encoder = Circuit()
 for i in range(qubits):
  encoder += RY(prg.new()).on(i)

 encoder = encoder.no_grad()

 return encoder

def convolution(label,qubits):
 count=0
 circ=Circuit()
 for i in range(2):
  circ+=RY(f'cov_{label}_{count}').on(qubits[i])
  count+=1
 circ+=X.on(qubits[1],qubits[0])

 return circ

def pooling(label,qubits,last=False):
 count=0
 circ=Circuit()
 for i in range(1):
  circ+=RZ(f'p_{label}_{count}').on(qubits[1],qubits[0])
  count+=1
  circ+=RX(f'p_{label}_{count}').on(qubits[1],qubits[0])         
  count+=1

 return circ

def split_qlist(qlist):     
 n=len(qlist)     
 flist=[]     
 slist=[]     
 if n>1:         
  for i in range(int(n/2)):             
   flist.append(qlist[2*i])             
   slist.append(qlist[2*i+1])     
 if n%2==1:         
  slist.append(qlist[-1])      

 return flist,slist

def Ansatz(qubits):
     assert qubits%2==0
     qlist=list(range(qubits))
     circ=Circuit()
     flist,slist=split_qlist(qlist)
     count=0
     while len(flist)>0:
         if len(flist)==1 and len(slist)==1:
             last=True
         else:
             last=False
         for i in range(len(flist)):
             q=[flist[i],slist[i]]
             circ+=convolution('blo_%s'%count,q)
             count+=1
             circ+=pooling('blo_%s'%count,q,last)
             count+=1
         flist,slist=split_qlist(slist)
      return circ

ansatz=Ansatz(10) 
encoder=Encoder(10)
circuit=encoder.as_encoder()+ansatz.as_ansatz()

ham = Hamiltonian(QubitOperator(f'Z{9}'))

ms.set_context(mode=ms.PYNATIVE_MODE, device_target="CPU")
ms.set_seed(1)
sim = Simulator('mqvector', circuit.n_qubits)
grad_ops = sim.get_expectation_with_grad(ham,
                                         circuit,
                                         parallel_worker=5)
QuantumNet = MQLayer(grad_ops)

cancer_file2_x=cancer_file2_x.drop(['radius_se', 'texture_se', 'perimeter_se', 'area_se', 'smoothness_se', 'compactness_se',                                     'concavity_se', 'concave points_se', 'symmetry_se', 'fractal_dimension_se', 'radius_worst',                                     'texture_worst', 'perimeter_worst', 'area_worst', 'smoothness_worst', 'compactness_worst',                                     'concavity_worst', 'concave points_worst', 'symmetry_worst', 'fractal_dimension_worst'],axis=1) 
cancer_file3_x=cancer_file3_x.drop(['radius_se', 'texture_se', 'perimeter_se', 'area_se', 'smoothness_se', 'compactness_se',                                     'concavity_se', 'concave points_se', 'symmetry_se', 'fractal_dimension_se', 'radius_worst',                                     'texture_worst', 'perimeter_worst', 'area_worst', 'smoothness_worst', 'compactness_worst',                                     'concavity_worst', 'concave points_worst', 'symmetry_worst', 'fractal_dimension_worst'],axis=1)

cancer_file2_x=(cancer_file2_x - cancer_file2_x.mean()) / (cancer_file2_x.std())#标准化

loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean') 
opti = Adam(QuantumNet.trainable_params(), learning_rate=20)  
model = Model(QuantumNet, loss, opti, metrics={'Acc': Accuracy()})   
train_loader = NumpySlicesDataset({'features': cancer_file2_x, 'labels': cancer_file2_y}, shuffle=True).batch(10) 
test_loader = NumpySlicesDataset({'features': cancer_file3_x, 'labels': cancer_file3_y}).batch(10)

class StepAcc(ms.Callback):
    def __init__(self,model,test_loader):
        self.model=model
        self.test_loader=test_loader
        self.acc=[]

    def on_train_step_end(self, run_context):
        self.acc.append(self.model.eval(self.test_loader, dataset_sink_mode=False)['Acc'])

monitor = LossMonitor(16) 
acc = StepAcc(model, test_loader) 
model.train(20, train_loader, callbacks=[monitor, acc], dataset_sink_mode=False)