├── A0_configuration.py
├── A1_videoAttributes.py
├── A2_getPicData.py
├── A3_zipPicData.py
├── A4_structureDataStructure.py
├── B0_singleVarAna.py
├── B1_integratedVarAna.py
├── B2_Frame2VecDPLBuilding.py
├── C0_clusterModelBuilding.py
├── C1_getClusDiv.py
├── C2_cutMovie.py
├── D0_Integration.py
├── D1_generalizingClipSeries.py
├── E0_GeneralizingFrame.py
├── README.md
├── tryDPModel.py
├── tryFFmpeg.py
└── tryFrame2Vec.py


/A0_configuration.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年11月23日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | 
 8 | import os
 9 | import shutil
10 | 
11 | def main():
12 |     '''
13 |     configurate the programme, mainly build and clear data
14 |     '''
15 |     dirList=["figures","imageDatas","log","models","movie","structuredData"]
16 |     
17 |     print("making up dirs ...")
18 |     for dirItem in dirList:
19 |         if dirItem not in list(os.listdir(".")):
20 |             os.mkdir(dirItem)
21 |     
22 |     print("clearing dirs ...")
23 |     clearList=["imageDatas","log"]
24 |     for dirItem in clearList:
25 |         if len(list(os.walk(dirItem)))>0:
26 |             shutil.rmtree(dirItem)
27 |             os.mkdir(dirItem)
28 |     
29 | if __name__ == '__main__':
30 |     main()


--------------------------------------------------------------------------------
/A1_videoAttributes.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年116
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | import cv2 
 8 | 
 9 | def main(videoPath='movie/antMan2.mp4'):
10 |     '''
11 |     description of the movie
12 |     '''
13 |     vc = cv2.VideoCapture(videoPath) 
14 |     print("total numer of frames:",vc.get(7))
15 |     print("frame rate:",vc.get(5))
16 |     print("total time:",vc.get(7)/vc.get(5)/3600,"h")
17 |     print("width",vc.get(3),"px")
18 |     print("height:",vc.get(4),"px")
19 | 
20 | if __name__ == '__main__':
21 |     vc = cv2.VideoCapture('movie/antMan2.mp4') 
22 |     print("total numer of frames:",vc.get(7))
23 |     print("frame rate:",vc.get(5))
24 |     print("total time:",vc.get(7)/vc.get(5)/3600,"h")
25 |     print("width",vc.get(3),"px")
26 |     print("height:",vc.get(4),"px")


--------------------------------------------------------------------------------
/A2_getPicData.py:
--------------------------------------------------------------------------------
  1 | #coding:utf8
  2 | '''
  3 | Created on 2018年11月6日
  4 | reference:
  5 | https://www.jb51.net/article/135972.htm
  6 | @author: Administrator
  7 | '''
  8 | import cv2 
  9 | import os
 10 | import shutil
 11 | from PIL import Image
 12 | def main(videoPath,abstractMode="part",timeF=10,checkF=200,imgNum=-1):
 13 |     '''
 14 |     get data in image frame from the video
 15 |     ----------------------------------------
 16 |     videoPath: the path of the source video
 17 |     imgPath: the path of the images to be saved
 18 |     timeF: distinct between images
 19 |     checkF: check whether the programme is running every <checkF> frames
 20 |     imgNum: 
 21 |         if it is -1, then travel the whole video
 22 |         else get <imgNum> images and then stop
 23 |     
 24 |     '''
 25 |     imgPath="imageDatas"
 26 |     
 27 |     print("loading video ...")
 28 |     vc = cv2.VideoCapture(videoPath)
 29 |     
 30 |     print("checking whether is open ...")
 31 |     if vc.isOpened():
 32 |         rval , frame = vc.read() 
 33 |     else: 
 34 |         rval = False
 35 |     i=0    
 36 |     c=1
 37 |     
 38 |     print("developing images ...")
 39 |     if abstractMode=="part":
 40 |         print("distinct between images is",timeF)
 41 |         while rval:
 42 |             if i<0:
 43 |                 continue
 44 |             rval, frame = vc.read() 
 45 |             if(c%timeF == 0):
 46 |                 cv2.imwrite(imgPath+'/'+str(i) + '.jpg',frame)
 47 |                 i=i+1
 48 |                 if i%checkF==0:
 49 |                     print("the",i,"th photo")
 50 |             c = c + 1
 51 |             cv2.waitKey(1) 
 52 |             if imgNum!=-1:
 53 |                 if i==imgNum:
 54 |                     break
 55 |         vc.release()
 56 |     elif abstractMode=="total":
 57 |         print("distinct between images is",int(vc.get(7)/imgNum))
 58 |         totalFrameNum=vc.get(7)
 59 |         timeF=int(totalFrameNum/imgNum)
 60 |         while rval:
 61 |             if i<0:
 62 |                 continue
 63 |             rval, frame = vc.read() 
 64 |             if(c%timeF == 0):
 65 |                 cv2.imwrite(imgPath+'/'+str(i) + '.jpg',frame)
 66 |                 i=i+1
 67 |                 if i%checkF==0:
 68 |                     print("the",i,"th photo")
 69 |             c = c + 1
 70 |             cv2.waitKey(1) 
 71 |             if imgNum!=-1:
 72 |                 if i==imgNum:
 73 |                     break
 74 |         vc.release()
 75 |     else:
 76 |         raise NameError
 77 |         print("the divide mode's name is wrong")
 78 |     print("finished")
 79 |     
 80 | if __name__ == '__main__':
 81 |     
 82 |     main("movie/antMan2.mp4",abstractMode="part",timeF=77,checkF=200,imgNum=10)
 83 | #     
 84 | #     picNum=500
 85 | #     
 86 | #     print("clearing imageDatas ...")
 87 | #     if len(list(os.walk("imageDatas")))>0:
 88 | #         shutil.rmtree("imageDatas")
 89 | #         os.mkdir("imageDatas")
 90 | #     
 91 | #     timeF = 10
 92 | #     print("distinct between images is",timeF)
 93 | #     
 94 | #     print("loading video ...")
 95 | #     vc = cv2.VideoCapture('movie/antMan.mp4')
 96 | #     
 97 | #     print("checking whether is open ...")
 98 | #     if vc.isOpened(): #判断是否正常打开 
 99 | #         rval , frame = vc.read() 
100 | #     else: 
101 | #         rval = False
102 | #       
103 | #     
104 | #     i=0    
105 | #     c=1
106 | #     while rval:
107 | #         if i<0:
108 | #             continue
109 | #         rval, frame = vc.read() 
110 | #         if(c%timeF == 0):
111 | #             cv2.imwrite('imageDatas/'+str(i) + '.jpg',frame)
112 | #             i=i+1
113 | #             if i%100==0:
114 | #                 print("the",i,"th photo")
115 | #         c = c + 1
116 | #         cv2.waitKey(1) 
117 | #         if picNum!=-1:
118 | #             if i==picNum:
119 | #                 break
120 | #     vc.release()
121 | #     print("finished")


--------------------------------------------------------------------------------
/A3_zipPicData.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年11月7日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | 
 8 | from PIL import Image
 9 | import os
10 | import tqdm
11 | 
12 | def main(resizedWidth=36,resizedHeight=36,cutSubtitle=True):
13 |     '''
14 |     zip the image data
15 |     ----------------------------------------
16 |     imgPath: the path of the images to be saved
17 |     resizedWidth: the width that the images are going to be zipped
18 |     resizedHeight: the height that the images are going to be ziped
19 |     cutSubtitle:whether to cut subtitle (1/8 down part of the images)
20 |     '''
21 |     imgPath="imageDatas"
22 |     i=0
23 |     for _, _, files in os.walk(imgPath):
24 |         for f in tqdm.tqdm(files):
25 |             if i<0:
26 |                 continue
27 |             fp = os.path.join(imgPath,f)
28 |             img = Image.open(fp)
29 |             
30 |             if cutSubtitle==True:
31 |                 w, h = img.size
32 |                 img=img.crop((0,0,w,7/8*h))
33 |             else:
34 |                 print("not cut subtitles")
35 |                 pass
36 |             
37 |             img.resize((resizedWidth, resizedHeight)).save(fp, "JPEG")
38 |             img.close
39 |             i=i+1
40 | 
41 | if __name__ == '__main__':
42 |     i=0
43 |     resizedWidth=36
44 |     resizedHeight=36
45 |     for _, _, files in os.walk("imageDatas"):
46 |         for f in tqdm.tqdm(files):
47 |             if i<0:
48 |                 continue
49 |             fp = os.path.join("imageDatas",f)
50 |             img = Image.open(fp)
51 |             
52 |             print("cutting subtitles ...")
53 |             w, h = img.size
54 |             img=img.crop((0,0,w,7/8*h))
55 |             
56 |             print("resizing ...")
57 |             img.resize((resizedWidth, resizedHeight)).save(fp, "JPEG")
58 |             img.close
59 |             i=i+1
60 | 


--------------------------------------------------------------------------------
/A4_structureDataStructure.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年11月8日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | 
 8 | import os
 9 | import cv2
10 | import numpy as np
11 | import pickle as pkl
12 | 
13 |     
14 | windowSize=14
15 | step=1
16 | 
17 | def paddingSeq(row,maxLen):
18 |     neededShape=row[0].shape
19 |     while len(row)<maxLen:
20 |         row.append(np.zeros(neededShape))
21 |     return row
22 |     
23 | def main(windowSize=windowSize,step=step):
24 |     '''
25 |     structure the image data into structure of:
26 |      [[img1,img2,...,imgi-1,imgi+1,...imgn],[imgi]]
27 |     ----------------------------------------
28 |     imgPath: the path of the images to be saved
29 |     windowSize: the flow window's size
30 |     step: the flow window's step
31 |     '''
32 |     imgPath="imageDatas"
33 |     fileNameList= [[int(fileName.split(".")[0]) for fileName in fileNameList]\
34 |                     for _,_,fileNameList in os.walk(imgPath)]
35 |     fileNameList=fileNameList[0]
36 |     fileNameList=list(set(fileNameList))
37 |     
38 |     print("structuring ...")
39 |     structuredDataList=[[[cv2.imread(os.path.join(imgPath,str(fileNameItem)+".jpg"))/255\
40 |                      for fileNameItem in fileNameList[i:i+int(windowSize/2)]+fileNameList[i+int(windowSize/2)+1:windowSize]],\
41 |                      cv2.imread(os.path.join(imgPath,str(fileNameList[i+int(windowSize/2)]))+".jpg")/255]\
42 |       for i in range(0,len(fileNameList)-windowSize+1,step)]
43 |     lenList=[len(row[0]) for row in structuredDataList]
44 |     maxLen=max(lenList)
45 |     structuredDataList=[[paddingSeq(row[0],maxLen),row[1]] for row in structuredDataList]
46 |     
47 |     print("saving data ...")
48 |     if os.path.exists("structuredData")==False:
49 |         os.mkdir("structuredData")
50 |     with open("structuredData/seriesPkl.pkl","wb+") as seriesFile:
51 |         pkl.dump(structuredDataList,seriesFile)
52 |         
53 |     print("---finished!---")
54 |     print("-total structure:\n[[img[0],img[1],img[2],...,img[windowSize-1]],img[int(windowSize/2)]]")
55 |     print("-total shape:",np.array(structuredDataList).shape)
56 |     print("-single shape:",structuredDataList[0][0][0].shape)
57 |     print("---------------")
58 |     
59 |     return structuredDataList
60 | 
61 | if __name__ == '__main__':
62 |     main(windowSize=windowSize,step=step,jumpStep=True)
63 |     
64 |     


--------------------------------------------------------------------------------
/B0_singleVarAna.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年11月19日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | import pickle as pkl
 8 | import numpy as np
 9 | 
10 | def getSingleWindowVar(imgList):
11 |     '''
12 |     get a window's variance
13 |     imgList:a window of images
14 |     '''
15 |     print("-getting the window's variance...")
16 |     windowVar=np.mean([np.var([imgItem[:,:,i] for imgItem in imgList])\
17 |                         for i in range(3)])
18 |     return windowVar
19 |     
20 | def main():
21 |     print("loading data ...")
22 |     with open("structuredData/seriesPkl.pkl","rb") as imgSeqDataFile:
23 |         imgSeqList=pkl.load(imgSeqDataFile)
24 |         
25 |     print("calculating the average variance...")
26 |     meanVar=np.mean([getSingleWindowVar(windowItem[0]) for windowItem in imgSeqList])
27 |     
28 |     print("---finished!---")
29 |     print("the average variance is:",meanVar)
30 |     print("---------------")
31 |     return meanVar
32 |     
33 | if __name__ == '__main__':
34 |     
35 |     print("loading data ...")
36 |     with open("structuredData/seriesPkl.pkl","rb") as imgSeqDataFile:
37 |         imgSeqList=pkl.load(imgSeqDataFile)
38 |         
39 |     print("calculating the average variance...")
40 |     meanVar=np.mean([getSingleWindowVar(windowItem[0]) for windowItem in imgSeqList])
41 |     
42 |     print("---finished!---")
43 |     print("the average variance is:",meanVar)
44 |     


--------------------------------------------------------------------------------
/B1_integratedVarAna.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年11月19日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | import A4_structureDataStructure as A4
 8 | import B0_singleVarAna as B0
 9 | import matplotlib
10 | matplotlib.use('Agg')
11 | import matplotlib.pyplot as plt
12 | import numpy as np
13 | import pickle as pkl
14 | import tqdm
15 | 
16 | def main(startPoint,endPoint,varSearchStep):
17 |     '''
18 |     search the best window size to define the variance
19 |     startPoint: the start point to expand the size of the window
20 |     endPoint: the end point of the expansion of the size of the window
21 |     varSearchStep: the change step of expansion of the size of the window
22 |     '''
23 |     try:
24 |         with open("structuredData/varListFile.pkl","rb") as varListFile:
25 |             windowVarList=pkl.load(varListFile)
26 |     except:
27 |         windowVarList=[]
28 |         
29 |     print("calculating variances...")
30 |     for windowSizeI in tqdm.tqdm(range(startPoint,endPoint,varSearchStep)):
31 |         A4.main(windowSize=windowSizeI,step=windowSizeI)
32 |         #A4 changed the file which is needed in B0
33 |         windowVarList.append((windowSizeI,B0.main()))
34 |     windowVarList=np.array(windowVarList)
35 |     print("the window variances are:",windowVarList)
36 |     
37 |     print("saving variance list ...")
38 |     with open("structuredData/varListFile.pkl","wb") as varListFile:
39 |         pkl.dump(windowVarList.tolist(),varListFile)
40 |     
41 |     print("saving var figure ...")
42 |     plt.plot(windowVarList[:,0],windowVarList[:,1])
43 |     plt.savefig("figures/varSeries_Figure.jpg")
44 |     plt.close()
45 |     
46 |     varList=[varI[1] for varI in windowVarList]
47 |     minVar=min(varList)
48 |     for row in windowVarList:
49 |         if row[1]==minVar:
50 |             bestSize=row[0]
51 |     
52 |     print("the best window's size is",int(bestSize))
53 |     
54 |     return int(bestSize)
55 |     
56 |     
57 | if __name__ == '__main__':
58 |     try:
59 |         with open("structuredData/varListFile.pkl","rb") as varListFile:
60 |             windowVarList=pkl.load(varListFile)
61 |     except:
62 |         windowVarList=[]
63 |         
64 |     print("calculating variances...")
65 |     for windowSizeI in tqdm.tqdm(range(20,40,1)):
66 |         A4.main(windowSize=windowSizeI,step=windowSizeI)
67 |         windowVarList.append((windowSizeI,B0.main()))
68 |     windowVarList=np.array(windowVarList)
69 |     print("the window variances are:",windowVarList)
70 |     
71 |     print("saving variance list ...")
72 |     with open("structuredData/varListFile.pkl","wb") as varListFile:
73 |         pkl.dump(windowVarList.tolist(),varListFile)
74 |     
75 |     plt.plot(windowVarList[:,0],windowVarList[:,1])
76 |     plt.show()


--------------------------------------------------------------------------------
/B2_Frame2VecDPLBuilding.py:
--------------------------------------------------------------------------------
  1 | #coding:utf8
  2 | '''
  3 | Created on 2018年11月22日
  4 | 
  5 | @author: Administrator
  6 | '''
  7 | from tryDPModel import MyModel
  8 | 
  9 | import pickle as pkl
 10 | import numpy as np
 11 | 
 12 | import keras
 13 | from keras.models import Model
 14 | from keras.callbacks import TensorBoard
 15 | 
 16 | def main(imgWidth,\
 17 |          imgHeight,\
 18 |          kernel_size = (3,3),\
 19 |          validation_split=0.5,\
 20 |          epochs=250,\
 21 |          batch_size = 50,\
 22 |          nb_filters = 32,\
 23 |          img_num=9,\
 24 |          img_passes=3,\
 25 |          pool_size = 5,\
 26 |          vecLen=100):
 27 |     
 28 |     print("loading data ...")
 29 |     with open("structuredData/seriesPkl.pkl","rb") as structuredDataFile:
 30 |         myData=pkl.load(structuredDataFile)
 31 |     x_train=[row[0] for row in myData]
 32 |     x_train=[[row[i] for row in x_train] for i in range(len(x_train[0]))]
 33 | #     print(len(x_train))
 34 |     y_train=[row[1] for row in myData]
 35 | #     print(y_train)
 36 |     print("building model ...")
 37 |     cnnGenModel=MyModel(img_rows=imgHeight,\
 38 |                         img_cols=imgWidth,\
 39 |                         kernel_size = kernel_size,\
 40 |                         validation_split=validation_split,\
 41 |                         epochs=epochs,\
 42 |                         batch_size = batch_size,\
 43 |                         nb_filters = nb_filters,\
 44 |                         img_num=img_num,\
 45 |                         img_passes=img_passes,\
 46 |                         pool_size = pool_size,\
 47 |                         vecLen=vecLen).buildCNNSeriesModel()
 48 |                           
 49 |     print("training model ...")
 50 |     cnnGenModel.fit(x_train,np.array(y_train),\
 51 |                     validation_split=validation_split,\
 52 |                     epochs=epochs,\
 53 |                     batch_size=batch_size,\
 54 |                     callbacks=[TensorBoard(log_dir="./log")])
 55 |      
 56 |     print("saving training model ...")
 57 | #     cnnGenModel.save("models/DPModel.h5")
 58 |     cnnGenModel=keras.models.load_model("models/DPModel.h5")
 59 |     
 60 |     print("predicting model construction ...")
 61 |     intermediate_layer_model = Model(inputs=cnnGenModel.input, 
 62 |                                  outputs=cnnGenModel.get_layer("vector_dense").output)
 63 |     
 64 |     print("saving generation model ...")
 65 |     intermediate_layer_model.save("models/DPGenModel.model")
 66 |     
 67 |     print("predicting ...")
 68 |     reStruMovieList=[intermediate_layer_model.predict([[col[i]] for col in x_train])[0] for i in range(len(x_train[0]))]
 69 |     
 70 |     print("saving restructured data prepared for cluster ...")
 71 |     with open("structuredData/reStruMovieList.pkl","wb+") as reStruMovieListFile:
 72 |         pkl.dump(reStruMovieList,reStruMovieListFile)
 73 |         
 74 |     print("finished!")
 75 | 
 76 | if __name__ == '__main__':
 77 |     
 78 |     print("loading data ...")
 79 |     with open("structuredData/seriesPkl.pkl","rb") as structuredDataFile:
 80 |         myData=pkl.load(structuredDataFile)
 81 |     x_train=[row[0] for row in myData]
 82 |     x_train=[[row[i] for row in x_train] for i in range(len(x_train[0]))]
 83 | #     print(len(x_train))
 84 |     y_train=[row[1] for row in myData]
 85 | #     print(y_train)
 86 |     print("building model ...")
 87 |     cnnGenModel=MyModel(img_rows=36,\
 88 |                         img_cols=36,\
 89 |                         kernel_size = (3,3)).buildCNNSeriesModel()
 90 |                         
 91 |     print("training model ...")
 92 |     cnnGenModel.fit(x_train,np.array(y_train),\
 93 |                     validation_split=0.5,\
 94 |                     epochs=1,\
 95 |                     callbacks=[TensorBoard(log_dir="./log")])
 96 |     
 97 |     print("saving training model ...")
 98 |     cnnGenModel.save("models/DPModel.model")
 99 |     
100 |     print("predicting model construction ...")
101 |     intermediate_layer_model = Model(inputs=cnnGenModel.input, 
102 |                                  outputs=cnnGenModel.get_layer("vector_dense").output)
103 |     
104 |     print("saving generation model ...")
105 |     intermediate_layer_model.save("models/DPGenModel.model")
106 |     
107 |     print("predicting ...")
108 |     reStruMovieList=[intermediate_layer_model.predict([[col[i]] for col in x_train])[0] for i in range(len(x_train[0]))]
109 |     
110 |     print("saving restructured data prepared for cluster ...")
111 |     with open("structuredData/reStruMovieList.pkl","wb+") as reStruMovieListFile:
112 |         pkl.dump(reStruMovieList,reStruMovieListFile)
113 |         
114 |     print("finished!")


--------------------------------------------------------------------------------
/C0_clusterModelBuilding.py:
--------------------------------------------------------------------------------
  1 | #coding:utf8
  2 | '''
  3 | Created on 2018年11月22日
  4 | 
  5 | @author: Administrator
  6 | '''
  7 | import pickle as pkl
  8 | import tqdm
  9 | import numpy as np
 10 | from Bio.Cluster import kcluster 
 11 | from sklearn import metrics
 12 | import matplotlib
 13 | matplotlib.use('Agg')
 14 | import matplotlib.pyplot as plt
 15 | import os
 16 | from PIL import Image as Img
 17 | 
 18 | def main(clusterStarter=2,\
 19 |          clusterEnder=9,\
 20 |          clusterStep=2):
 21 |     
 22 |     ssList=[]
 23 |     clusterListList=[]
 24 |     
 25 |     print("loading data ...")
 26 |     with open("structuredData/reStruMovieList.pkl","rb") as reStruMovieListFile:
 27 |         reStruMovieList=pkl.load(reStruMovieListFile)
 28 |     clusterRange=range(clusterStarter,clusterEnder,clusterStep)
 29 |     for i in tqdm.tqdm(clusterRange):
 30 |         reStruMovieArr=np.array(reStruMovieList)
 31 | #         clusterModel=KMeans(n=i)
 32 | #         clusterList=clusterModel.fit_predict(reStruMovieArr).tolist()
 33 |         clusterList=kcluster(reStruMovieArr,nclusters=i,dist="u",npass=150)[0].tolist()
 34 |         clusterListList.append(clusterList)
 35 |         clusterMat=-np.dot(reStruMovieArr,reStruMovieArr.T)/\
 36 |                     np.dot(np.sqrt(np.sum(reStruMovieArr*reStruMovieArr,axis=1)),\
 37 |                            np.sqrt(np.sum(reStruMovieArr*reStruMovieArr,axis=1)))
 38 |         ss=metrics.silhouette_score(clusterMat, clusterList, metric="precomputed")
 39 |         ssList.append(ss)
 40 |     maxIndex=ssList.index(max(ssList))
 41 |     maxClu=list(clusterRange)[maxIndex]
 42 |     
 43 |     print("the best cluster number is",maxClu)
 44 |     
 45 |     print("developing figures...")
 46 |     plt.plot(np.array(list(clusterRange)),np.array(ssList))
 47 |     clusterListArr=np.array(clusterListList)
 48 |     clusterListArrMaxNum=np.max(clusterListArr)
 49 |     clusterListArr=clusterListArr/clusterListArrMaxNum*255
 50 |     clusterListImg=Img.fromarray(clusterListArr)
 51 |     clusterListImg=clusterListImg.resize((500,1000))
 52 |     
 53 |     print("saving figure ...")
 54 |     plt.savefig("figures/clustering_figure.jpg")
 55 |     plt.close()
 56 |     clusterListImg=clusterListImg.convert('RGB')
 57 |     clusterListImg.save("figures/clusterList_figure.png")
 58 |     
 59 |     print("clustering ...")
 60 |     bestClusterList=kcluster(reStruMovieArr,nclusters=maxClu)[0].tolist()
 61 |     
 62 |     print("saving data ...")
 63 |     with open("structuredData/bestClusterList.pkl","wb+") as bestClusterListFile:
 64 |         pkl.dump(bestClusterList,bestClusterListFile)
 65 |     
 66 |     print("finished!")
 67 |     
 68 | if __name__ == '__main__':
 69 |     
 70 |     ssList=[]
 71 |     clusterListList=[]
 72 |     clusterStarter=2
 73 |     clusterEnder=9
 74 |     clusterStep=2
 75 |     
 76 |     print("loading data ...")
 77 |     with open("structuredData/reStruMovieList.pkl","rb") as reStruMovieListFile:
 78 |         reStruMovieList=pkl.load(reStruMovieListFile)
 79 |     
 80 |     clusterRange=range(clusterStarter,clusterEnder,clusterStep)
 81 |     for i in tqdm.tqdm(clusterRange):
 82 |         reStruMovieArr=np.array(reStruMovieList)
 83 | #         clusterModel=KMeans(n=i)
 84 | #         clusterList=clusterModel.fit_predict(reStruMovieArr).tolist()
 85 |         clusterList=kcluster(reStruMovieArr,nclusters=i,dist="u",npass=150)[0].tolist()
 86 |         clusterListList.append(clusterList)
 87 |         clusterMat=-np.dot(reStruMovieArr,reStruMovieArr.T)/\
 88 |                     np.dot(np.sqrt(np.sum(reStruMovieArr*reStruMovieArr,axis=1)),\
 89 |                            np.sqrt(np.sum(reStruMovieArr*reStruMovieArr,axis=1)))
 90 |         ss=metrics.silhouette_score(clusterMat, clusterList, metric="precomputed")
 91 |         ssList.append(ss)
 92 |     maxIndex=ssList.index(max(ssList))
 93 |     maxClu=list(clusterRange)[maxIndex]
 94 |     
 95 |     print("developing figures...")
 96 |     plt.plot(np.array(list(clusterRange)),np.array(ssList))
 97 |     clusterListArr=np.array(clusterListList)
 98 |     clusterListArrMaxNum=np.max(clusterListArr)
 99 |     clusterListArr=clusterListArr/clusterListArrMaxNum*255
100 |     clusterListImg=Img.fromarray(clusterListArr)
101 |     clusterListImg=clusterListImg.resize((500,1000))
102 |     
103 |     print("saving figure ...")
104 |     plt.savefig("figures/clustering_figure.jpg")
105 |     clusterListImg=clusterListImg.convert('RGB')
106 |     clusterListImg.save("figures/clusterList_figure.png")
107 |     plt.close()
108 |     
109 |     print("clustering ...")
110 |     bestClusterList=kcluster(reStruMovieArr,nclusters=maxClu)[0].tolist()
111 |     
112 |     print("saving data ...")
113 |     with open("structuredData/bestClusterList.pkl","wb+") as bestClusterListFile:
114 |         pkl.dump(bestClusterList,bestClusterListFile)
115 |     
116 |     print("finished!")
117 | 


--------------------------------------------------------------------------------
/C1_getClusDiv.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年11月23日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | import pickle as pkl
 8 | import numpy as np
 9 | import matplotlib
10 | import matplotlib.pyplot as plt
11 | 
12 | def isCutPoint(cmpedArr):
13 |     if cmpedArr[0]-cmpedArr[1]==0:
14 |         return False
15 |     else:
16 |         return True
17 |     
18 | def main(varSize=50,divideMethod="mean",thresholdAdj=0.1,showFig=False):
19 |     
20 |     windowStep=1
21 |     
22 |     print("loading data ...")
23 |     with open("structuredData/bestClusterList.pkl","rb") as bestClusterListFile:
24 |         bestClusterArr=np.array(pkl.load(bestClusterListFile))
25 |     i=0
26 |     varList=[]
27 |     
28 |     print("moving var ...")
29 |     while i+varSize<bestClusterArr.shape[0]:
30 |         varList.append(np.var(bestClusterArr[i:i+varSize]))
31 |         i+=windowStep
32 |     varArr=np.array(varList)
33 |     
34 |     print("moving filter ...")
35 |     print("divide method:",divideMethod)
36 |     if divideMethod=="mean":
37 |         threshold=np.mean(varArr)
38 |     elif divideMethod=="median":
39 |         threshold=np.median(varArr)
40 |     elif divideMethod=="hptp":
41 |         threshold=np.ptp(varArr)/2+np.min(varArr)
42 |     else:
43 |         raise("err in divide method")
44 |     threshold=threshold+thresholdAdj
45 |     zeroOneVarArr=np.array([int(varItem>threshold) for varItem in varArr.tolist()])\
46 |                     *np.max(varArr)
47 |     
48 |     print("get cut point in the frame of fraction of the movie ...")
49 |     cutPointList=[i/zeroOneVarArr.shape[0] for i in range(zeroOneVarArr.shape[0]-1) if isCutPoint(zeroOneVarArr[i:i+2])==True]
50 |     cutPointList=[0]+cutPointList+[1]
51 |      
52 |      
53 |     clipLenMean=np.mean([cutPointList[lenI+1]-cutPointList[lenI]\
54 |                   for lenI in range(len(cutPointList)-1)])
55 |     clipLenStd=np.sqrt(np.var([cutPointList[lenI+1]-cutPointList[lenI]\
56 |                   for lenI in range(len(cutPointList)-1)]))
57 |      
58 |     print("the mean length is",clipLenMean)
59 |     print("the var of length is",clipLenStd)
60 |     
61 |     tempCutPointList=cutPointList.copy()
62 |     for lenI in range(len(cutPointList)-1):
63 |         if cutPointList[lenI+1]-cutPointList[lenI]<clipLenMean-clipLenStd:
64 |             tempCutPointList.remove(cutPointList[lenI])
65 |   
66 |     cutPointList=tempCutPointList
67 |     
68 |     zeroOneList=zeroOneVarArr.tolist()
69 |     
70 |     flag=np.max(varArr)
71 |     for cutI in range(len(cutPointList)-1):
72 |         for i in range(int(cutPointList[cutI]*zeroOneVarArr.shape[0]),\
73 |                            int(cutPointList[cutI+1]*zeroOneVarArr.shape[0])):
74 |             zeroOneList[i]=flag
75 |         if flag==np.max(varArr):flag=0
76 |         else:flag=np.max(varArr)
77 |     zeroOneVarArr=np.array(zeroOneList)
78 |     
79 |     print("developing figures ...")
80 |     zeroOneVarPlot,=plt.plot(zeroOneVarArr)
81 |     varPlot,=plt.plot(varArr)
82 |     thresholdPlot,=plt.plot(np.array([i for i in range(varArr.shape[0])]),[threshold for i in range(varArr.shape[0])])
83 |     plt.legend([zeroOneVarPlot,varPlot,thresholdPlot],\
84 |                ["clips","variances",divideMethod+" threshold"],\
85 |                loc="upper right")
86 |     
87 |     print("saving data and figures ...")
88 |     plt.savefig("figures/var_figure.jpg")
89 |     plt.close()
90 |     with open("structuredData/zeroOneArr.pkl","wb+") as zeroOneArrFile:
91 |         pkl.dump(zeroOneVarArr,zeroOneArrFile)
92 |     if showFig==True:
93 |         plt.show()
94 |     print("finished!")
95 |             
96 | if __name__ == '__main__':
97 |     main(showFig=True)


--------------------------------------------------------------------------------
/C2_cutMovie.py:
--------------------------------------------------------------------------------
  1 | #coding:utf8
  2 | '''
  3 | Created on 2018年11月23日
  4 | 
  5 | @author: Administrator
  6 | '''
  7 | 
  8 | import pickle as pkl
  9 | import numpy as np
 10 | import cv2
 11 | 
 12 | def isCutPoint(cmpedArr):
 13 |     if cmpedArr[0]-cmpedArr[1]==0:
 14 |         return False
 15 |     else:
 16 |         return True
 17 | 
 18 | def main():
 19 |     
 20 |     print("loading data ...")
 21 |     with open("structuredData/zeroOneArr.pkl","rb") as zeroOneArrFile:
 22 |         zeroOneArr=pkl.load(zeroOneArrFile)
 23 |         
 24 |     print("get cut point in the frame of fraction of the movie ...")
 25 |     cutPointList=[i/zeroOneArr.shape[0] for i in range(zeroOneArr.shape[0]-1) if isCutPoint(zeroOneArr[i:i+2])==True]
 26 |     cutPointList=[0]+cutPointList+[1]
 27 |     
 28 |     print("cut point list:",cutPointList)    
 29 |     
 30 |     vc = cv2.VideoCapture('movie/antMan2.mp4')
 31 |     
 32 |     clipI=0
 33 |     i=0
 34 |     while 1:
 35 |         if cutPointList[clipI]==0:
 36 |             print("generaling the",clipI+1,"th clip ...")
 37 |             videoWriter = cv2.VideoWriter('movie/clip'+str(clipI)+'.mp4',\
 38 |                                           cv2.VideoWriter_fourcc('X','V','I','D'),\
 39 |                                           vc.get(cv2.CAP_PROP_FPS),\
 40 |                                           frameSize=(int(vc.get(3)),int(vc.get(4))))
 41 |             clipI+=1
 42 |         success,frame=vc.read()
 43 |         if not success:
 44 |             print("finished")
 45 |             break
 46 |         if i<int(cutPointList[clipI]*vc.get(7)):
 47 |             videoWriter.write(frame)
 48 |         else:
 49 |             videoWriter.write(frame)
 50 |             print("generaling the",clipI+1,"th clip ...")
 51 |             videoWriter = cv2.VideoWriter('movie/clip'+str(clipI)+'.mp4',\
 52 |                                           cv2.VideoWriter_fourcc('X','V','I','D'),\
 53 |                                           vc.get(cv2.CAP_PROP_FPS),\
 54 |                                           frameSize=(int(vc.get(3)),int(vc.get(4))))
 55 |             clipI+=1
 56 |         if cv2.waitKey(100) & 0xFF == ord('q'):
 57 |             break
 58 |         i+=1
 59 |     print("finished!")
 60 | 
 61 | if __name__ == '__main__':
 62 |     
 63 |     videoPath="movie/antMan2.mp4"
 64 |     clipPath="movie"
 65 |     
 66 |     print("loading data ...")
 67 |     with open("structuredData/zeroOneArr.pkl","rb") as zeroOneArrFile:
 68 |         zeroOneArr=pkl.load(zeroOneArrFile)
 69 |         
 70 |     print("get cut point in the frame of fraction of the movie ...")
 71 |     cutPointList=[i/zeroOneArr.shape[0] for i in range(zeroOneArr.shape[0]-1) if isCutPoint(zeroOneArr[i:i+2],i/zeroOneArr.shape[0]-1)==True]
 72 |     cutPointList=[0]+cutPointList+[1]
 73 |     
 74 |     print(cutPointList)
 75 |     
 76 |     vc = cv2.VideoCapture('movie/antMan2.mp4')
 77 |     
 78 |     clipI=0
 79 |     i=0
 80 |     while 1:
 81 |         if cutPointList[clipI]==0:
 82 |             print("generaling the",clipI+1,"th clip ...")
 83 |             videoWriter = cv2.VideoWriter('movie/clip'+str(clipI)+'.mp4',\
 84 |                                           cv2.VideoWriter_fourcc('X','V','I','D'),\
 85 |                                           vc.get(cv2.CAP_PROP_FPS),\
 86 |                                           frameSize=(int(vc.get(3)),int(vc.get(4))))
 87 |             clipI+=1
 88 |         success,frame=vc.read()
 89 |         if not success:
 90 |             print("finished")
 91 |             break
 92 |         if i<int(cutPointList[clipI]*vc.get(7)):
 93 |             videoWriter.write(frame)
 94 |         else:
 95 |             videoWriter.write(frame)
 96 |             print("generaling the",clipI+1,"th clip ...")
 97 |             videoWriter = vc.VideoWriter('movie/clip'+str(clipI)+'.mp4',\
 98 |                                           cv2.VideoWriter_fourcc('X','V','I','D'),\
 99 |                                           vc.get(cv2.CAP_PROP_FPS),\
100 |                                           frameSize=(vc.get(3),vc.get(4)))
101 |             clipI+=1
102 |         if cv2.waitKey(100) & 0xFF == ord('q'):
103 |             break
104 |         i+=1
105 |     print("finished!")


--------------------------------------------------------------------------------
/D0_Integration.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年11月23日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | 
 8 | import os
 9 | import shutil
10 | import A0_configuration
11 | import A1_videoAttributes
12 | import A2_getPicData
13 | import A3_zipPicData
14 | import A4_structureDataStructure
15 | import B1_integratedVarAna
16 | import B2_Frame2VecDPLBuilding
17 | import C1_getClusDiv
18 | import C2_cutMovie
19 | import C0_clusterModelBuilding
20 | 
21 | 
22 | if __name__ == '__main__':
23 |     videoPath='movie/antMan2.mp4'
24 |     abstractMode="total"
25 |     timeF=4
26 |     checkF=200
27 |     imgNum=2200
28 |     resizedWidth=32
29 |     resizedHeight=32
30 |     cutSubtitle=True
31 |     structureStep=1
32 |     varWindowStartPoint=5
33 |     varWindowEndPoint=20
34 |     varWindowStep=2
35 |     
36 |     kernel_size = (3,3)
37 |     validation_split=0.5
38 |     epochs=50
39 |     batch_size = 32
40 |     nb_filters = 32
41 |     img_num=9
42 |     img_passes=3
43 |     pool_size = (5,5)
44 |     vecLen=150
45 |     
46 |     clusterVarWindowsSize=50
47 |     clusterVarDivideMethod="mean"
48 |     clusterVarShowFig=True
49 |     
50 |     clusterStarter=3
51 |     clusterEnder=12
52 |     clusterStep=2
53 |     thresholdAdj=+1
54 |     
55 |     clearVarList=True
56 |     if clearVarList==True:
57 |         if "varListFile.pkl" in os.listdir("structuredData"):
58 |             os.remove("structuredData/varListFile.pkl")
59 |     
60 |     bestWindowSizeByVarReOne=17
61 |     A0_configuration.main()
62 |     A1_videoAttributes.main(videoPath)
63 |     A2_getPicData.main(videoPath,abstractMode, timeF, checkF, imgNum)
64 |     A3_zipPicData.main(resizedWidth,resizedHeight,cutSubtitle)
65 |     bestWindowSizeByVarReOne=B1_integratedVarAna.main(varWindowStartPoint,varWindowEndPoint,varWindowStep)
66 |     A4_structureDataStructure.main(bestWindowSizeByVarReOne+1,structureStep)
67 |     B2_Frame2VecDPLBuilding.main(resizedWidth,\
68 |                                  resizedHeight,\
69 |                                  kernel_size = kernel_size,\
70 |                                  validation_split=validation_split,\
71 |                                  epochs=epochs,\
72 |                                  batch_size = batch_size,\
73 |                                  nb_filters = nb_filters,\
74 |                                  img_num=bestWindowSizeByVarReOne,\
75 |                                  img_passes=img_passes,\
76 |                                  pool_size = pool_size,\
77 |                                  vecLen=vecLen)
78 |     C0_clusterModelBuilding.main(clusterStarter,\
79 |                                  clusterEnder,\
80 |                                  clusterStep)
81 |     C1_getClusDiv.main(varSize=clusterVarWindowsSize,\
82 |                        divideMethod=clusterVarDivideMethod,\
83 |                        thresholdAdj=thresholdAdj,\
84 |                        showFig=clusterVarShowFig)
85 |     C2_cutMovie.main()
86 | 


--------------------------------------------------------------------------------
/D1_generalizingClipSeries.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年11月26日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | 
 8 | import pickle as pkl
 9 | import cv2
10 | import moviepy
11 | import win_unicode_console
12 | win_unicode_console.enable()
13 | from moviepy.video.io.VideoFileClip  import VideoFileClip
14 | from moviepy.video.compositing.concatenate import concatenate_videoclips
15 | 
16 | def isCutPoint(cmpedArr):
17 |     if cmpedArr[0]-cmpedArr[1]==0:
18 |         return False
19 |     else:
20 |         return True
21 | 
22 | def getVCItem(clipIndex,meanPreCutLen):
23 |     vc = VideoFileClip("movie/clip"+str(clipIndex)+".mp4")
24 |     vcLen=vc.duration
25 |     startPoint=vcLen/2-meanPreCutLen
26 |     endPont=vcLen/2
27 |     vcItem = vc.subclip(int(startPoint), int(endPont))
28 |     return vcItem
29 |     
30 | if __name__ == '__main__':
31 |     
32 |     totalTime=60#60 seconds
33 |     cutClipList=[1,3,4,7,8,10,11,12,13]
34 |     
35 |     meanPreCutLen=totalTime/len(cutClipList)
36 |     print("the average length of each clip:",meanPreCutLen)
37 |     
38 |     print("getting the preview's clips ...")
39 |     preCutPointList=[getVCItem(cci,meanPreCutLen) for cci in cutClipList]
40 |     
41 |     print("combining ...")
42 |     previewVideo=concatenate_videoclips(preCutPointList)
43 |     
44 |     print("saving")
45 |     previewVideo.to_videofile("movie/preview.mp4", fps=24, remove_temp=True)


--------------------------------------------------------------------------------
/E0_GeneralizingFrame.py:
--------------------------------------------------------------------------------
 1 | #coding:utf8
 2 | '''
 3 | Created on 2018年12月1日
 4 | 
 5 | @author: Administrator
 6 | '''
 7 | 
 8 | import keras
 9 | import pickle as pkl
10 | from keras.models import Model
11 | from PIL import Image
12 | 
13 | if __name__ == '__main__':
14 |     print("loading model ...")
15 |     cnnGenModel=keras.models.load_model("models/DPModel.h5")
16 |     
17 |     print("predicting model construction ...")
18 |     generalizeModel = Model(inputs=cnnGenModel.input, 
19 |                                  outputs=cnnGenModel.get_layer("vector_name").output)
20 |     
21 |     print("loading data ...")
22 |     with open("structuredData/seriesPkl.pkl","rb") as structuredDataFile:
23 |         myData=pkl.load(structuredDataFile)
24 |         
25 |     print("generalizing validation data ...")
26 |     X=myData[0][0]
27 |     y=myData[0][1]
28 |     
29 |     print("generalizing frame ...")
30 |     yPre=generalizeModel.predict(X)*255
31 |     img=Image.fromarray(yPre.astype('uint8')).convert('RGB')
32 |     img.imsave("structuredData/try_gen_fame.jpg")
33 |     
34 |     print("finished!")


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # AutoDivideMovie
2 |   sample of the result, see: https://www.bilibili.com/video/av37495576/<br /> 
3 |   =========Brochure============<br /> 
4 |   1.After downloading the zip into your workspace, unpack it and establish a folder named "movie";<br /> 
5 |   2.Put the movie you want to cut into the folder;<br /> 
6 |   3.Run D0_Integration (most of the parameters are in it, and you can change it), and you will find your clips in "movie";<br /> 
7 |   4.After adjusting the clip list you want to compile together in D1_generalizatingClipSeries, you can compile the clips together. But the result may be confused to some aspects, since it just gets the clip_in_full_movie_length/full_movie_length\*compiled_movie_ength around the peaks.
8 | 


--------------------------------------------------------------------------------
/tryDPModel.py:
--------------------------------------------------------------------------------
  1 | #coding:utf8
  2 | '''
  3 | Created on 2018年11月7日
  4 | 
  5 | @author: Administrator
  6 | '''
  7 | 
  8 | import numpy as np
  9 | import matplotlib.pyplot as plt
 10 | import pickle as pkl
 11 | 
 12 | from keras.datasets import mnist
 13 | from keras.models import Sequential,Model
 14 | from keras.layers.core import Dense, Activation, Dropout
 15 | from keras.utils import np_utils
 16 | from keras.datasets import mnist
 17 | from keras.models import Sequential
 18 | from keras.layers import Lambda,Input,Dense,Reshape, Activation, Convolution2D, MaxPooling2D, Flatten, Bidirectional
 19 | from keras.layers import Convolution2D, MaxPooling2D
 20 | from keras.utils import np_utils
 21 | from keras.layers.recurrent import LSTM
 22 | from keras import backend as K
 23 | from keras.callbacks import TensorBoard
 24 | 
 25 | from Bio.Cluster import kcluster 
 26 | from sklearn import metrics
 27 | import tqdm
 28 | 
 29 | class MyModel:
 30 |     
 31 |     def covLoss(self,y_true, y_pred):
 32 |         ytVar=K.var(y_true)
 33 |         ypVar=K.var(y_pred)
 34 |         cov=(ytVar+ypVar)/2
 35 |         return cov
 36 |         
 37 |     
 38 |     def __init__(self,**kwargs):
 39 |         '''
 40 |         you can design any kinds of model in this class
 41 |         ***note:add <subtitles>***
 42 |         ==================================================
 43 |         for <CNNClassifierModel>:
 44 |         
 45 |         batch_size(default: 50):batch size
 46 |         nb_classes(default: 10):the number of classes
 47 |         nb_epoch(default: 12):the number of epoch
 48 |         nb_filters(default: 32):the number of filters
 49 |         img_rows(default: 28 ):the height of matrixes
 50 |         img_cols(default: 28):the width of matrixes
 51 |         pool_size(default: (2,2)):the size of pools
 52 |         kernel_size(default: (3,3)): the size of kernels
 53 |         ==================================================
 54 |         for <**model name**>
 55 |         parameter
 56 |         '''
 57 |         self.paraDict=kwargs
 58 |     
 59 |     def buildCNNSeriesModel(self,\
 60 |                                 nb_filters = 32,\
 61 |                                 img_num=16,\
 62 |                                 img_rows=256,\
 63 |                                 img_cols =256,\
 64 |                                 img_passes=3,\
 65 |                                 pool_size = 5,\
 66 |                                 kernel_size = (8,8),
 67 |                                 vecLen=100):
 68 |         '''
 69 |         batch_size(default: 50):batch size
 70 |         nb_filters(default: 32):the number of filters
 71 |         img_rows(default: 28 ):the height of matrixes
 72 |         img_cols(default: 28):the width of matrixes
 73 |         img_passes(defaulst: 3):the passages of tensors
 74 |         pool_size(default: (2,2)):the size of pools
 75 |         kernel_size(default: (3,3)): the size of kernels
 76 |         '''
 77 |             
 78 |         try:
 79 |             self.nb_filters = self.paraDict['nb_filters']
 80 |         except:
 81 |             self.nb_filters =nb_filters
 82 |             
 83 |         try:
 84 |             self.img_rows, self.img_cols = self.paraDict['img_rows'],self.paraDict['img_cols']
 85 |         except:
 86 |             self.img_rows, self.img_cols =img_rows, img_cols
 87 |             
 88 |         try:
 89 |             self.pool_size = self.paraDict['pool_size']
 90 |         except:
 91 |             self.pool_size = pool_size
 92 |             
 93 |         try:
 94 |             self.kernel_size = self.paraDict['kernel_size']
 95 |         except:
 96 |             self.kernel_size=kernel_size
 97 |         
 98 |         try:
 99 |             self.img_passes=self.paraDict['img_passes']
100 |         except:
101 |             self.img_passes=img_passes
102 |             
103 |         try:
104 |             self.img_num=self.paraDict['img_num']
105 |         except:
106 |             self.img_num=img_num
107 |         
108 |         try:
109 |             self.vecLen=self.paraDict['vecLen']
110 |         except:
111 |             self.vecLen=vecLen
112 |         self.input_shape = (self.img_num,self.img_rows, self.img_cols,self.img_passes)
113 |         
114 |         denseList=[]
115 |         inputList=[Input(shape=self.input_shape[1:]) for i in range(self.img_num)]
116 |         for i in range(self.img_num):
117 |             conv2DL1=Convolution2D(self.nb_filters,\
118 |                                    input_shape=self.input_shape,\
119 |                                    kernel_size=(self.kernel_size[0],self.kernel_size[1]),\
120 |                                    border_mode='valid',\
121 |                                    activation="relu",\
122 |                                    data_format="channels_last")(inputList[i])
123 |             print(conv2DL1)
124 |             maxPoolL1=MaxPooling2D(pool_size=pool_size,\
125 |                                   padding="same",\
126 |                                   data_format="channels_last")(conv2DL1)
127 |             print(maxPoolL1)
128 |             conv2DL2=Convolution2D(self.nb_filters,\
129 |                                    kernel_size=(self.kernel_size[0],self.kernel_size[1]),\
130 |                                    border_mode='valid',\
131 |                                    activation="relu",\
132 |                                    data_format="channels_last")(maxPoolL1)
133 |             print(conv2DL2)
134 |             maxPoolL2=MaxPooling2D(pool_size=pool_size,\
135 |                                   padding="same",\
136 |                                   data_format="channels_last")(conv2DL2)
137 |             print(maxPoolL2)
138 |             denseL1=Dense(units=16,activation="relu")(maxPoolL2)
139 |             print(denseL1)
140 |             flattenL=Flatten()(denseL1)
141 |             print(flattenL)
142 |             denseL2=Dense(units=64,activation="relu")(flattenL)
143 |             print(denseL2)
144 |             denseList.append(Reshape((64,1))(denseL2))
145 |         concateL=Lambda(K.concatenate)(denseList)
146 |         print(concateL)
147 |         BLSTML=Bidirectional(LSTM(units=64,activation="relu"))(concateL)
148 |         print(BLSTML)
149 |         denseL3=Dense(units=self.vecLen,activation="relu",name="vector_dense")(BLSTML)
150 |         denseL4=Dense(units=self.img_rows*self.img_cols*self.img_passes,activation="tanh")(denseL3)
151 |         reshapeL=Reshape((self.img_rows,self.img_cols,self.img_passes),name="vector_name")(denseL4)
152 |         print(reshapeL)
153 |         
154 |         model=Model(inputs=inputList,outputs=reshapeL)
155 |         model.compile(optimizer="rmsprop",\
156 |                       loss="mse")
157 |         
158 |         return model
159 |         
160 |     def buildCNNClassifierModel(self,\
161 |                                 batch_size = 50,\
162 |                                 nb_classes = 10,\
163 |                                 nb_epoch = 12,\
164 |                                 nb_filters = 32,\
165 |                                 img_rows=28,\
166 |                                 img_cols =28,\
167 |                                 pool_size = (2,2),\
168 |                                 kernel_size = (3,3)):
169 |         '''
170 |         batch_size(default: 50):batch size
171 |         nb_classes(default: 10):the number of classes
172 |         nb_epoch(default: 12):the number of epoch
173 |         nb_filters(default: 32):the number of filters
174 |         img_rows(default: 28 ):the height of matrixes
175 |         img_cols(default: 28):the width of matrixes
176 |         pool_size(default: (2,2)):the size of pools
177 |         kernel_size(default: (3,3)): the size of kernels
178 |         '''
179 |         try:
180 |             self.batch_size = self.paraDict['batch_size']
181 |         except:
182 |             self.batch_size=batch_size
183 |             
184 |         try:
185 |             self.nb_classes = self.paraDict['nb_classes']
186 |         except:
187 |             self.nb_classes=nb_classes
188 |             
189 |         try:
190 |             self.nb_epoch = self.paraDict['nb_epoch']
191 |         except:
192 |             self.nb_epoch=nb_epoch
193 |             
194 |         try:
195 |             self.nb_filters = self.paraDict['nb_filters']
196 |         except:
197 |             self.nb_filters =nb_filters
198 |             
199 |         try:
200 |             self.img_rows, self.img_cols = self.paraDict['img_rows'],self.paraDict['img_cols']
201 |         except:
202 |             self.img_rows, self.img_cols =img_rows, img_cols
203 |             
204 |         try:
205 |             self.pool_size = self.paraDict['pool_size']
206 |         except:
207 |             self.pool_size = pool_size
208 |             
209 |         try:
210 |             self.kernel_size = self.paraDict['kernel_size']
211 |         except:
212 |             self.kernel_size=kernel_size
213 |             
214 |         self.input_shape = (self.img_rows, self.img_cols,1)
215 |             
216 |         model = Sequential()
217 |         
218 |         model.add(Convolution2D(self.nb_filters, self.kernel_size[0] ,self.kernel_size[1],
219 |                                 border_mode='valid',
220 |                                 input_shape=self.input_shape))
221 |         model.add(Activation('relu'))
222 |         
223 |         # 卷积层，激活函数是ReLu
224 |         model.add(Convolution2D(self.nb_filters, self.kernel_size[0], self.kernel_size[1]))
225 |         model.add(Activation('relu'))
226 |         
227 |         # 池化层，选用Maxpooling，给定pool_size，dropout比例为0.25
228 |         model.add(MaxPooling2D(pool_size=self.pool_size))
229 |         model.add(Dropout(0.25))
230 |         
231 |         # Flatten层，把多维输入进行一维化，常用在卷积层到全连接层的过渡
232 |         model.add(Flatten())
233 |         
234 |         # 包含128个神经元的全连接层，激活函数为ReLu，dropout比例为0.5
235 |         model.add(Dense(128))
236 |         model.add(Activation('relu'))
237 |         model.add(Dropout(0.5))
238 |         
239 |         # 包含10个神经元的输出层，激活函数为Softmax
240 |         model.add(Dense(self.nb_classes))
241 |         model.add(Activation('softmax'))
242 |         
243 |         model.compile(loss='categorical_crossentropy',
244 |               optimizer='adadelta',
245 |               metrics=['accuracy'])
246 |         
247 |         model.summary()
248 |         
249 |         self.DPmodel=model
250 |         
251 |         return model
252 |     
253 | if __name__ == '__main__':
254 |     print("loading data ...")
255 |     with open("structuredData/seriesPkl.pkl","rb") as structuredDataFile:
256 |         myData=pkl.load(structuredDataFile)
257 |     x_train=[row[0] for row in myData]
258 |     x_train=[[row[i] for row in x_train] for i in range(len(x_train[0]))]
259 | #     print(len(x_train))
260 |     y_train=[row[1] for row in myData]
261 | #     print(y_train)
262 |     print("building model ...")
263 |     cnnGenModel=MyModel(img_rows=36,\
264 |                         img_cols=36,\
265 |                         kernel_size = (3,3)).buildCNNSeriesModel()
266 |     cnnGenModel.fit(x_train,np.array(y_train),epochs=100,\
267 |                     callbacks=[TensorBoard(log_dir="./log")])
268 |     intermediate_layer_model = Model(inputs=cnnGenModel.input, 
269 |                                  outputs=cnnGenModel.get_layer("dense_27").output)
270 |     reStruMovieList=[intermediate_layer_model.predict([[col[i]] for col in x_train])[0] for i in range(len(x_train[0]))]
271 |     
272 |     ssList=[]
273 |     clusterListList=[]
274 |     clusterRange=range(2,19,2)
275 |     for i in tqdm.tqdm(clusterRange):
276 |         reStruMovieArr=np.array(reStruMovieList)
277 | #         clusterModel=KMeans(n=i)
278 | #         clusterList=clusterModel.fit_predict(reStruMovieArr).tolist()
279 |         clusterList=kcluster(reStruMovieArr,nclusters=i,dist="u")[0].tolist()
280 |         clusterListList.append(clusterList)
281 |         clusterMat=-np.dot(reStruMovieArr,reStruMovieArr.T)/\
282 |                     np.dot(np.sqrt(np.sum(reStruMovieArr*reStruMovieArr,axis=1)),\
283 |                            np.sqrt(np.sum(reStruMovieArr*reStruMovieArr,axis=1)))
284 |         ss=metrics.silhouette_score(clusterMat, clusterList, metric="precomputed")
285 |         ssList.append(ss)
286 |     minIndex=ssList.index(min(ssList))
287 |     minClu=list(clusterRange)[minIndex]
288 |     
289 |     plt.plot(np.array(list(clusterRange)),np.array(ssList))
290 |     plt.show()
291 |     
292 |     print(clusterListList[1])
293 | #     clusterModel=KMeans(n_clusters=minClu)
294 | #     clusterList=clusterModel.fit_predict(reStruMovieArr).tolist()
295 | #     print(np.array(clusterList))
296 |     


--------------------------------------------------------------------------------
/tryFFmpeg.py:
--------------------------------------------------------------------------------
1 | #coding:utf8
2 | '''
3 | Created on 2018年11月7日
4 | 
5 | @author: Administrator
6 | '''
7 | 
8 | if __name__ == '__main__':
9 |     pass


--------------------------------------------------------------------------------
/tryFrame2Vec.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Timaos123/AutoDivideMovie/e12b2439db8b55dd802aec32f4113c2c4c4d4b40/tryFrame2Vec.py


--------------------------------------------------------------------------------