Conclusion
The objective of this internship was to develop an industrial process flow as to optimise the photomask generation.
After an introduction chapter, the theoretical background was presented in the second chapter, photolithography challenges, parameters, as well as Machine Learning knowledge up to advanced generative algorithms were presented.
In the third chapter, the model we used for two sub-problematics is explained, as well as how we decided to implement it.
In the fourth chapter, we considered the whole process flow from the very beginning with the GDSII file till the end with the Machine Learning algorithm. All the steps in between we created were detailed, taking into account the Lithography limitations, the Machine Learning requirements, the results of the testing of such algorithms on simple datasets, their adaptation to our problematic, as well as the implementation of the physics-based loss function.
In the frame of this work, we developed a reproducible and well-detailed process flow which takes layout designs as an Input, and outputs a photomask generated using both AI and physics equations.
This result although not perfect nor completely finished as of yet and still subject to improve-ments encourages me to work in similar fields later, with the combination of microelectronics-related domains and AI-microelectronics-related tools. This would probably lead me to take example on my supervisor P. Urard who switched from a technical job to project management but still being fully involved on high-tech research projects.
Appendixes
Project organisation and unfolding
The research group was formed of Mr. Urard as the lead Director, and a handful of interns working on different subjects. During this project, I realised in the beginning of December that it would be difficult to have a running flow in the end of my internship because of a lack of time. Indeed, I was the only one working on this project for 4 months, and before I arrived, no real idea of the flow, nor scripts which could help me had been done.
I also had to set up the whole UNIX environment to run different software such as Calibre or TensorFlow, which is a long procedure of more than 1 week within the company. Then I had to create by myself a Variational Auto Encoder, turn it into a GAN, and I had no knowledge at first of those tools. So that, I decided to try my best to have a whole flow running, developing DRC scripts to process the data, I also suggested the whole flow, worked on the theoretical part, and implemented it.
Then in mid-December, the project changed to the defocus robustness problematic, with the new strategy being to add SRAF, as it seemed simpler and a better path for the company. I therefore had to create new scripts, focus on new problems (such as the one of layers), and when a second intern and a colleague arrived in mid-February, I could delegate some of the tasks, especially with the DRC scripts, as to focus on more testing and assembling the flow with them.
To conclude, this project really had two phases, both of them blending together in the very end of my internship, and it required multidisciplinary skills to be achieved, although a lot of improvements are still to be done.
Figure 32: GANTT diagram of the project
Glossary
• AI : Artificial Intelligence (generally refers to Deep Learning applications).
• CUDA : Compute Unified Device Architecture, used to take advantage of multiple cores on a Graphics Processing Unit.
• DRC : Design Rules Check : a set of rules for a desifgn to be manufacturable AND a file format to run script within Mentor’s Calibre.
• DUV : Deep Ultra Violet (around 13.5 nm).
• EDA : Electronic design automation.
• ELBO : Evidence lower bound (value of the loss function at a given epoch).
• GAN : Generative Adversarial Network : Deep Learning model to generate data, detailed in the first Chapter.
• GDSII : A vectorial file format for layouts.
• GPU : Graphics Processing Unit.
• ILT : Inverse Lithography Techniques, the goal being to generate a "perfect" mask given a design.
• MNIST : Modified National Institute of Standards and Technology, which is a large database of handwritten digits that is commonly used for training various image processing systems.
• NA : Numerical Aperture, a dimensionless number that characterises the range of angles over which the system can accept or emit light.
• OPC : Optical Proximity Correction, which is a set of methods trying to simplify ILT by iterative rules.
• PNG : Portable Network Graphics, an image file format with a lossless compression.
• PSM : Phase-shift mask, to improve the contrast of the on-resist design after exposure.
• PSF : Point Spread Function, which describes the response of an imaging system to a point source or point object.
• RAM : Random Access Memory, where is stored our data when running the algorithm.
• SRAF: Sub-Resolution Assist Features, or added "bars" on the mask to improve the contrast and a focus robustness to the mask.
• SVG : Scalable Vector Graphics, a vectorial image format with a lossless compression.
• SVM : Support Vector Machine, an algorithm to extract features of data and find hyperplanes separating those features. It is detailed in the Chapter 1, and allows for data generation.
• VAE : Variational Auto Encoder, a Stochastic Deep Learning model to encode and decode data, allowing for features extraction and generation of data. It is described in the Chapter 1.
Cost analysis
The achievement of my master thesis relies on several costs:
- My salary and a percentage of the salary of all the engineers working partially on the project should be considered.
- The software licenses (Calibre, Microsoft Office, IEEE documents): This cost also is not easy to evaluate as the same licenses are used by several engineers, and the prices are not always given within the company.
- The special hardware to which I had access such as the computer, the GPU, and the computing farm.
- The advantages over the food and other activities funded by the Company’s Committee.
Python code samples
1 # * c o d i n g : utf 8 *
-2 i m p o r t n u m p y as np ; i m p o r t sys ; np . s e t _ p r i n t o p t i o n s ( t h r e s h o l d = sys . m a x s i z e ) ; i m p o r t m at h
3 # b e s s e l f u n c t i o n of o r d e r 1
4 f r o m s c i p y . s p e c i a l i m p o r t jv ; i m p o r t m a t p l o t l i b . p y p l o t as plt ; o r d e r = 1 ; r e s o l u t i o n = 1 0 * 1 0 * * - 9
5 def B e s s e l c a r d i n a l ( order , x ) :
6 if x = = 0 :
7 r e t u r n 0.5
8 r e t u r n 2* jv ( order , x ) /( x )
9
10 def c o n v o l u t i o n ( arrbig , a r r s m a l l , i , j ) :
11 # d e f i n i t i o n of the c o n v o l u t i o n o p e r a t i o n w i t h an i m a g e and a s m a l l e r k e r n e l
12 c o n v o = 0 . 0
13 for a in r a n g e(0 ,len( a r r s m a l l ) ) :
14 for b in r a n g e (0 , len( a r r s m a l l ) ) :
15 if i +int(len( a r r s m a l l ) /2) -a >=0 and j +int(len( a r r s m a l l ) /2) -b >=0 and ( i + int(len( a r r s m a l l ) /2) - a ) < len ( a r r b i g ) and ( j +int(len( a r r s m a l l ) /2) - b ) < len ( a r r b i g ) :
16 c o n v o += a r r b i g [ i +int(len( a r r s m a l l ) /2) - a ][ j +int(len( a r r s m a l l ) /2) - b ]*
a r r s m a l l [ a ][ b ]
17 r e t u r n c o n v o
18
19 def p h y s i c s l o s s ( a , lambd , thresh , na , mask , target , r e s o l u t i o n ) :
20 # i n i t i a l i s a t i o n
21 Z = [[0 for j in r a n g e(len( m a s k ) ) ] for i in r a n g e(len( m a s k ) ) ] ; fl = [[0 for j in r a n g e(len( m a s k ) ) ] for i in r a n g e(len( m as k ) ) ] ; c o n v o l v e d = [[0 for j in r a n g e(len( m a s k ) ) ] for i in r a n g e(len( m a s k ) ) ] ; a r r2 = [[0 for j in r a n g e(len ( m a s k ) ) ] for i in r a n g e(len( m a s k ) ) ] ; g r a d = [[0 for j in r a n g e(len( m a s k ) ) ]
for i in r a n g e(len( m a s k ) ) ] ; I = [[0 for j in r a n g e(len( m as k ) ) ] for i in r a n g e(len( m a s k ) ) ]
22 # s i z e of the c o n v o l u t i o n kernel , f i x e d at 15 for the e x a m p l e
23 # l e n g h = int ( len ( ma s k ) /4) *2 ; # w i d h = int ( len ( m a s k ) /4) *2
24 l e n g h = 15 ; w id h = 15
25 h = [ [ 0 for j in r a n g e( l e n g h ) ] for i in r a n g e( wi d h ) ]
26 # c o m m o n v a r i a b l e
27 v a r 1 = 2* m a t h . pi * na / l a m b d
28 # We l o o p on all the e l e m e n t s of b e s s e l c a r d i n a l k e r n e l to c a l c u l a t e it
29 for i in r a n g e(0 , l e n g h ) :
30 for j in r a n g e(0 , w i d h ) :
31 # d i s t a n c e f r o m c e n t e r of m a s k
32 r = m a t h . s q r t (( i -( lengh -1) /2) **2 +( j -( widh -1) /2) * * 2 ) * r e s o l u t i o n
33 # b e s s e l f u n c t i o n + p o i n t s p r e a d
34 h [ i ][ j ]= B e s s e l c a r d i n a l (1 , r * v a r 1 )
35
36 for i in r a n g e(0 ,len( m a s k ) ) :
37 for j in r a n g e(0 ,len( m a s k [ i ]) ) :
38 # c o n v o l u t i o n b e t w e e n h and m a s k
39 c o n v o l v e d [ i ][ j ] = c o n v o l u t i o n ( mask , h , i , j )
40 # l i g h t i n t e n s i t y as d e f i n e d
41 I [ i ][ j ] = abs( c o n v o l v e d [ i ][ j ]) **2
42 # r e s i s t m o d e l a d d e d to the i n t e n s i t y
43 Z [ i ][ j ]= 1 / ( 1 + np . exp ( - a *( I [ i ][ j ] - t h r e s h ) ) )
# l2 n o r m
45 fl [ i ][ j ]= ( t a r g e t [ i ][ j ] - Z [ i ][ j ]) **2
46 # u s e f u l for c a l c u l a t i o n of g r a d i e n t
47 a r r 2 [ i ][ j ]= ( t a r g e t [ i ][ j ] - Z [ i ][ j ]) * Z [ i ][ j ] *(1 - Z [ i ][ j ]) * c o n v o l v e d [ i ][ j ]
48 for i in r a n g e(0 ,len( m a s k ) ) :
49 for j in r a n g e(0 ,len( m a s k [ i ]) ) :
50 # g r a d i e n t m a t r i x c a l c u l a t i o n
51 g r a d [ i ][ j ]= -2* a * c o n v o l u t i o n ( arr2 , np . r o t 9 0 ( np . a r r a y ( h ) ,2) . t o l i s t () ,i , j )
52 # l o s s c a l c u l a t i o n
53 l o s s = np .sum( np . a r r a y ( fl ) )
54 r e t u r n ( l os s )
55
56 # t e s t i n g and s e t t i n g p a r a m e t e r s
57 s =50 ; a , lambd , thresh , na , mask , t a r g e t = 10 , ( 1 9 3 * 1 0 * * - 9 ) , 0.8 , 1.35 , [ [ 0 ] * s ]* s , [ [ 0 ] * s ]* s
58
59 p r i n t(" l o s s = ", p h y s i c s l o s s ( a , lambd , thresh , na , mask , target , r e s o l u t i o n ) )
60
61 # p r i n t the map of B e s s e l c a r d i n a l c o e f f i c i e n t s
62
63 def b e s s e l m a p ( r e s o l u t i o n , size , na , lambd , thr ) :
64 # f u n c t i o n to s h o w the map of B e s s e l c a r d i n a l c o e f f i c i e n t s
65 h = [ [ 0 for j in r a n g e( s i z e ) ] for i in r a n g e( s i z e ) ]
66 v a r 1 = 2* m a t h . pi * na / l a m b d
67 for i in r a n g e(0 ,len( h ) ) :
68 for j in r a n g e(0 ,len( h [ i ]) ) :
69 r = m a t h . s q r t (( i -(len( h ) -1) /2) **2 +( j -(len( h ) -1) /2) * * 2 ) * r e s o l u t i o n
70 h [ i ][ j ]= int( ( 1 +abs( B e s s e l c a r d i n a l (1 , r * v a r1 ) ) - thr ) )
71 r e t u r n np . a r r a y ( h )
72
73 p r i n t(" \ n \ n b e s s e l map = ") ;
74 plt . i m s h o w ( b e s s e l m a p (10*10** -9 ,110 , na , lambd , 1 / 1 5 0 ) ) ; plt . s h o w ()
Listing 1: Python code for model-based ILT
1 def p r e p a r e _ f o r _ t r a i n i n g ( ds , c a c h e = True ,
2 s h u f f l e _ b u f f e r _ s i z e = 1 0 0 0 ) :
3 if c a c h e :
4 if i s i n s t a n c e( cache , str) :
5 ds = ds . c a c h e ( c a c h e )
6 e l s e:
7 ds = ds . c a c h e ()
8 ds = ds . s h u f f l e ( b u f f e r _ s i z e = s h u f f l e _ b u f f e r _ s i z e )
9 ds = ds . r e p e a t ()
10 ds = ds . b a t c h ( i m a g e _ c o u n t )
11 ds = ds . p r e f e t c h ( b u f f e r _ s i z e = A U T O T U N E )
12 r e t u r n ds
13
14 t r a i n _ d s = p r e p a r e _ f o r _ t r a i n i n g ( l a b e l e d _ d s )
15 i m a g e _ b a t c h , l a b e l _ b a t c h = n e x t(i t e r( t r a i n _ d s ) )
16 t r a i n _ i m a g e s = i m a g e _ b a t c h . n u m p y ()
17 t r a i n _ i m a g e s =( t r a i n _ i m a g e s .max( a x i s =3) + t r a i n _ i m a g e s .min( ax i s =3) ) /2 # G r e y S c a l e C o n v e r s i o n
18 t r a i n _ i m a g e s = t r a i n _ i m a g e s . r e s h a p e ( t r a i n _ i m a g e s . s h a p e [0] , 128 ,
19 128 , 1) . a s t y p e (’ f l o a t 3 2 ’) # r e s h a p i n g
20
21 # B i n a r i s a t i o n
22 t r a i n _ i m a g e s [ t r a i n _ i m a g e s >= .9] = 1.
23 t r a i n _ i m a g e s [ t r a i n _ i m a g e s < .9] = 0.
24
Listing 2: Python code for pre-processing
Specific details
Convolution
Here is an illustration of how the convolution (or cross correlation) in different part of the project works, be it in the physics-based loss function, or inside convolution layers.
The filter is also called kernel, and it is the small array which allows the convolution to take place and therefore emphasise (or not) the surroundings of the source pixel, depending on the kernel construction.
In the case of our physics-based model, we chose a 15x15 kernel with the coefficients of the Bessel cardinal function as defined in the body of the report.
We can also mathematically write it as :
R~ k(i, j) =
n
X
a=1 n
X
b=1
R(i − a + jn
2 k
, j − b + jn
2 k
) × k(a, b), (9)
with R our initial image, k our kernel of dimension n × n and (i, j) the coordinate of the pixel we want to compute (the source pixel).
Figure 33: Convolution Layer summary
Manufacturability Rules (DRC)
Figure 34: Manufacturability rules 1
Figure 35: Manufacturability rules 2
Figure 36: Manufacturability rules 3
Figure 37: Manufacturability rules 4
DRC code sample for manufacturability check
Here is an extract of the code, and the parameters we had to manually set up in order to be able to check if a given mask is manufacturable. The complete code for this is exactly 1115 lines of commands, so that we will only give the definition of some of variables here and an example of a zone check. This is only useful to show what a DRC script looks like and the work we had to deal with to remotely control Mentor’s Calibre.
1 // # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
2 // # # # # # # V A R I A B L E D E F I N I T I O N # # # # #
3 // # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
4 // s c r i p t p a r a m e t e r s
5 / / # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
6 V A R I A B L E p r e c i s i o n _ g d s 1 0 0 0
7 V A R I A B L E dbu 1.0 / p r e c i s i o n _ g d s
8 V A R I A B L E n u m b e r 29
9
10 // M D R C V a r i a b l e s
11 / / # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
12 V A R I A B L E M i n _ w i d t h _ C D _ M D R C 0 . 0 4 8
13 V A R I A B L E M i n _ s p a c e _ M D R C 0 . 0 3
14 V A R I A B L E M i n _ w i d t h _ c o r n e r _ t o _ c o r n e r _ o u t e r _ M D R C 0 . 0 3 6
15 V A R I A B L E M i n _ s p a c e _ c o r n e r _ t o _ c o r n e r _ o u t e r _ M D R C 0 . 0 2 2
16 V A R I A B L E M i n _ p r o j e c t i n g _ l e n g t h _ M D R C 0 . 0 0 5
17 V A R I A B L E M i n _ p r o j e c t i n g _ a d j u s t m e n t _ M D R C 0 . 0 2 2
18 V A R I A B L E M i n _ p r o j e c t i n g _ l e n g t h _ 1 _ M D R C 0 . 0 6 8
19 V A R I A B L E M i n _ p r o j e c t i n g _ a d j u s t m e n t _ 1 _ M D R C 0 . 0 2 5
20 V A R I A B L E M i n _ p r o j e c t i n g _ w i d t h _ l e n g t h _ M D R C 0 . 0 3 2
21 V A R I A B L E M i n _ p r o j e c t i n g _ w i d t h _ a d j u s t m e n t _ M D R C 0 . 0 3 6
22 V A R I A B L E M i n _ p r o j e c t i n g _ w i d t h _ l e n g t h _ 1 _ M D R C 0 . 0 5 6
23 V A R I A B L E M i n _ p r o j e c t i n g _ w i d t h _ a d j u s t m e n t _ 1 _ M D R C 0 . 0 4 2
24 V A R I A B L E M a x _ s h a r e d _ j o i n i n g _ l e n g t h _ M D R C -0.001
25
26 [ . . . ]
27
28 // # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
29 // # # # # # / / 5.1 M I N _ S P A C E _ C H E C K _ Z O N E _ D E F
30 // # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
31 M I N _ S P A C E _ M D R C = E X T E R N A L M D R C _ C H E C K < M i n _ s p a c e _ M D R C O P P O S I T E P R O J E C T I N G > 0 . 0 0 3
32 M I N _ S P A C E _ R E G I O N _ M D R C = E X T E R N A L M D R C _ C H E C K < M i n _ s p a c e _ M D R C O P P O S I T E P R O J E C T I N G > 0 . 0 0 3 R E G I O N
33 // R e g i o n for d e f e c t v i e w
References
[1] Daniel Abrams and Linyong Pang. Fast inverse lithography technology. Proc SPIE, 6154, 03 2006.
[2] Siu Kai Choy, Ningning Jia, Chong-Sze Tong, Man-Lai Tang, and Edmund Lam. A robust computational algorithm for inverse photomask synthesis in optical projection lithography.
SIAM Journal on Imaging Sciences [electronic only], 5, 01 2012.
[3] Daphne Cornelisse. An intuitive guide to convolutional neural networks, 2018.
[4] Partha Ghosh, Mehdi S. M. Sajjadi, Antonio Vergari, Michael Black, and Bernhard Schölkopf.
From variational to deterministic autoencoders. 03 2019.
[5] H. H. Hopkins. The concept of partial coherence in optics. Proceedings of the Royal Society of London. Series A, Mathematical and Physical Sciences, 208(1093):263–277, 1951.
[6] Xun Huang, Ming-Yu Liu, Serge Belongie, and Jan Kautz. Multimodal unsupervised image-to-image translation. 04 2018.
[7] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for genera-tive adversarial networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, PP:1–1, 01 2020.
[8] Diederik Kingma and Max Welling. Auto-encoding variational bayes. 12 2014.
[9] Yibo Lin, Mohamed Baker Alawieh, Wei Ye, and David Pan. Machine learning for yield learning and optimization. 11 2018.
[10] Xu Ma, Qile Zhao, Hao Zhang, Zhiqiang Wang, and Gonzalo Arce. Model-driven convolution neural network for inverse lithography. Optics Express, 26:32565, 12 2018.
[11] Rance Rodrigues, Aswin Sreedhar, and Sandip Kundu. Optical lithography simulation using wavelet transform. Proceedings - IEEE International Conference on Computer Design: VLSI in Computers and Processors, pages 427 – 432, 11 2009.
[12] Hao Tang, Dan Xu, Hong Liu, and Nicu Sebe. Asymmetric generative adversarial networks for image-to-image translation. 12 2019.
[13] H.Y. Yang, Shuhe Li, Zihao Deng, Yuzhe Ma, Bei Yu, and Evangeline Young. Gan-opc:
Mask optimization with lithography-guided generative adversarial nets. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, PP:1–1, 09 2019.
[14] Yujie Zhang and Wenjing Ye. Deep learning based inverse method for layout design. 2018.
[15] Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. CoRR, abs/1703.10593, 2017.
Emilien Chevallier
Nanotech student
Deep Learning High-Tech Engineering Passionate about Dynamic Research Environments 3rdYear Internship at STMicroelectronics
Grenoble InnoVallée Global semiconductor leader Artificial Intelligence Simulation
Physics Modelling
Emphasis on team work