Hollywood, Health & Society (HH&S), a program of the USC Annenberg Norman Lear Center, has unveiled the winners of the 2024 Sentinel Awards, which recognize some of the past year’s best TV entertainment that responsibly informs audiences on critical topics.

"Abbott Elementary," "Expats" and "Hacks" Are Among Shows Set To Receive Sentinel Awards - SHOOTonline

USC Annenberg Norman Lear Center's Hollywood, Health & Society program will honor advocacy stories on 'Grey's Anatomy' and more with Sentinel Awards.

‘Grey’s Anatomy,’ ‘Hacks,’ ‘The Simpsons’ Among Series to Be Honored by Hollywood, Health & Society’s Sentinel Awards

The 2024 Sentinel Awards, organized by the Hollywood, Health & Society program at the USC Annenberg Norman Lear Center, will honor shows like 'Hacks.'

Sentinel Awards 2024 Winners Include 'The Morning Show,' 'Hacks,' More

Laurens County will see nearly 500 new jobs come to the area after an international automotive parts company opens their new manufacturing facility.

More than 450 jobs are coming to Laurens County as auto parts company opens facility

Real-time index price for S&P 500 Growth (IGX), along with buy or sell indicators, analysis, charts, historical performance, news and more

Consumer Discretionary Stocks Are at It Again! Don’t Miss Out on These Potential Winners!

The United Auto Workers union says it reached a tentative contract with General Motors, the last of the Detroit Three automakers to agree to a deal. Under the deal reached

UAW reaches deal with General Motors that ends strikes against Detroit automakers pending votes

The supplier of seats for the Ford Bronco has given pay raises to workers at its plant in Detroit in a bid to keep them from leaving for other jobs and to protect its business as it ramps up for the post-strike production rush.

UAW strike spurs pay raise for workers at Ford supplier

Fintel reports that on October 30, 2023, Barclays maintained coverage of Lear (NYSE:LEA) with a Overweight recommendation. Analyst Price Forecast Suggests 36.07% Upside As of October 5, 2023, the average one-year price target for Lear is 174.

Barclays Maintains Lear (LEA) Overweight Recommendation

Fintel reports that on October 30, 2023, Benchmark reiterated coverage of Lear (NYSE:LEA) with a Buy recommendation. Analyst Price Forecast Suggests 36.07% Upside As of October 5, 2023, the average one-year price target for Lear is 174.

Benchmark Reiterates Lear (LEA) Buy Recommendation

Automotive tier-1 supplier Lear Corporation has reported its results for the third quarter of 2023, with a sales increase of 10% year-on-year to US$5.8 billion.

Fifth consecutive quarter of growth for Lear Corp in Q3

Lear

lear

Authors:
(1) Corby Rosset, Microsoft Research and Correspondence to corbyrosset@microsoft.com;
(2) Ching-An Cheng, Microsoft Research;
(3) Arindam Mitra, Microsoft Research;
(4) Michael Santacroce, Microsoft Research;
(5) Ahmed Awadallah, Microsoft Research and Correspondence to hassanam@microsoft.com;
(6) Tengyang Xie, Microsoft Research and Correspondence to tengyangxie@microsoft.com. Table of Links Abstract and 1 Introduction 2 Preliminaries 2.1 RLHF Based on Reward Models 2.2 RLHF with General Preferences 3 Direct Nash Optimization and 3.1 Derivation of Algorithm 1 3.2 Theoretical Analysis 4 Practical Algorithm – Iterative Contrastive Self-Improvement 5 Experiments and 5.1 Experimental Setup 5.2 Results and Analysis 6 Related Work 7 Conclusion and References Appendix A Extension to Regularized Preferences B Detailed Proofs C Additional Experimental Details 4 Practical Algorithm – Iterative Contrastive Self-Improvement In this section, we shift our focus to the algorithmic design of the practically scalable version of DNO, following the principles discussed in the last section. A primary challenge encountered in the implementation of the conceptual algorithm DNO (Algorithm 1) stems from the necessity to compute the expectation with respect to the preference function P under the current policy πt. Perhaps surprisingly, as we will show, all we need is a properly implemented iterative DPO-like contrastive learning algorithm. We present our the practical implementation of DNO in Algorithm 2 (DNO-Prct), which is a batched on-policy algorithm that conducts self-improvement iteratively via contrastive learning. One key consideration in our algorithmic design is that we only need to implicitly use the reward function rt. This comes from the specifically designed on-policy sampling, data filtering, and pair construction. While these specific design choices make DNO-Prct seem similar to simply performing DPO iteratively, there are significant reasons for these design decisions, as we will discuss below. Relationship between DNO-Prct and DPO. The reader may discern that DNO-Prct (Algorithm 2)—the practical implementation of DNO—can be described as an iterative version of the DPO algorithm. Such similarity is by design, intended to harness the simplicity and effectiveness of DPO (Rafailov et al., 2023) and build on empirical advancements from recent work that applies DPO iteratively (e.g., Yuan et al., 2024; Tran et al., 2024). Our experiments point to the importance of several design choices which help accommodate the general preferences, such as rankings derived from pair-wise win rates. More interestingly, our findings point to a surprising connection—that “a meticulously designed iterative DPO algorithm” could approach the Nash equilibrium of any given general preferences. Our general algorithmic framework—DNO (Algorithm 1)—is broader and fundamentally different from iterative DPO. For example, the DNO framework could also be directly extended to the regularized preference case (as discussed in Appendix A) or equipped with other advanced sample techniques (e.g., Liu et al., 2024b, RSO) as suggested by Theorem 1 for sample efficiency. On the other hand, although the soft policy iteration (or the KL-regularized reward optimization) is used in both DNO and DPO, they arise from fundamentally different reasons. For DNO, KL-regularization originates from online learning, no-regret learning through mirror descent (Nemirovskĳ and Yudin, 1983) or followthe-regularized-leader (FTRL) (Kalai and Vempala, 2005; Cesa-Bianchi and Lugosi, 2006; Shalev-Shwartz et al., 2012; Hazan et al., 2016). For DPO and PPO, the KL-regularization is an approximation for the total variation penalty to ensure monotonic improvement of the policy (Kakade and Langford, 2002; Schulman et al., 2015). Later, this approach was simplified by Schulman et al. (2017, PPO), and recently used for post-training LLMs (Ouyang et al., 2022). This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Corby Rosset, Microsoft Research and Correspondence to corbyrosset@microsoft.com; (2) Ching-An Cheng, Microsoft Research; (3) Arindam Mitra, Microsoft Research; (4) Michael Santacroce, Microsoft Research; (5) Ahmed Awadallah, Microsoft Research and Correspondence to hassanam@microsoft.com; (6) Tengyang Xie, Microsoft Research and Correspondence to tengyangxie@microsoft.com. Authors: Authors: (1) Corby Rosset, Microsoft Research and Correspondence to corbyrosset@microsoft.com; (2) Ching-An Cheng, Microsoft Research; (3) Arindam Mitra, Microsoft Research; (4) Michael Santacroce, Microsoft Research; (5) Ahmed Awadallah, Microsoft Research and Correspondence to hassanam@microsoft.com; (6) Tengyang Xie, Microsoft Research and Correspondence to tengyangxie@microsoft.com. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Preliminaries 2 Preliminaries 2.1 RLHF Based on Reward Models 2.1 RLHF Based on Reward Models 2.2 RLHF with General Preferences 2.2 RLHF with General Preferences 3 Direct Nash Optimization and 3.1 Derivation of Algorithm 1 3 Direct Nash Optimization and 3.1 Derivation of Algorithm 1 3.2 Theoretical Analysis 3.2 Theoretical Analysis 4 Practical Algorithm – Iterative Contrastive Self-Improvement 4 Practical Algorithm – Iterative Contrastive Self-Improvement 5 Experiments and 5.1 Experimental Setup 5 Experiments and 5.1 Experimental Setup 5.2 Results and Analysis 5.2 Results and Analysis 6 Related Work 6 Related Work 7 Conclusion and References 7 Conclusion and References Appendix Appendix A Extension to Regularized Preferences A Extension to Regularized Preferences B Detailed Proofs B Detailed Proofs C Additional Experimental Details C Additional Experimental Details 4 Practical Algorithm – Iterative Contrastive Self-Improvement In this section, we shift our focus to the algorithmic design of the practically scalable version of DNO, following the principles discussed in the last section. A primary challenge encountered in the implementation of the conceptual algorithm DNO (Algorithm 1) stems from the necessity to compute the expectation with respect to the preference function P under the current policy πt. Perhaps surprisingly, as we will show, all we need is a properly implemented iterative DPO-like contrastive learning algorithm. We present our the practical implementation of DNO in Algorithm 2 (DNO-Prct), which is a batched on-policy algorithm that conducts self-improvement iteratively via contrastive learning. One key consideration in our algorithmic design is that we only need to implicitly use the reward function rt. This comes from the specifically designed on-policy sampling, data filtering, and pair construction. While these specific design choices make DNO-Prct seem similar to simply performing DPO iteratively, there are significant reasons for these design decisions, as we will discuss below. Relationship between DNO-Prct and DPO. The reader may discern that DNO-Prct (Algorithm 2)—the practical implementation of DNO—can be described as an iterative version of the DPO algorithm. Such similarity is by design, intended to harness the simplicity and effectiveness of DPO (Rafailov et al., 2023) and build on empirical advancements from recent work that applies DPO iteratively (e.g., Yuan et al., 2024; Tran et al., 2024). Our experiments point to the importance of several design choices which help accommodate the general preferences, such as rankings derived from pair-wise win rates. More interestingly, our findings point to a surprising connection—that “a meticulously designed iterative DPO algorithm” could approach the Nash equilibrium of any given general preferences. Relationship between and “a meticulously designed iterative “a meticulously designed iterative algorithm” could approach the Nash equilibrium of any given general preferences. algorithm” could approach the Nash equilibrium of any given general preferences. Our general algorithmic framework—DNO (Algorithm 1)—is broader and fundamentally different from iterative DPO. For example, the DNO framework could also be directly extended to the regularized preference case (as discussed in Appendix A) or equipped with other advanced sample techniques (e.g., Liu et al., 2024b, RSO) as suggested by Theorem 1 for sample efficiency. On the other hand, although the soft policy iteration (or the KL-regularized reward optimization) is used in both DNO and DPO, they arise from fundamentally different reasons. For DNO, KL-regularization originates from online learning, no-regret learning through mirror descent (Nemirovskĳ and Yudin, 1983) or followthe-regularized-leader (FTRL) (Kalai and Vempala, 2005; Cesa-Bianchi and Lugosi, 2006; Shalev-Shwartz et al., 2012; Hazan et al., 2016). For DPO and PPO, the KL-regularization is an approximation for the total variation penalty to ensure monotonic improvement of the policy (Kakade and Langford, 2002; Schulman et al., 2015). Later, this approach was simplified by Schulman et al. (2017, PPO), and recently used for post-training LLMs (Ouyang et al., 2022). This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

How Contrastive Learning Helps AI Self-Improve

Hoe kontrastiewe leer help AI selfverbeter

Com l'aprenentatge contrastant ajuda a la IA a millorar-se

Πώς η αντίθετη μάθηση βοηθά την αυτοβελτίωση

Cómo el aprendizaje contrastante ayuda a la IA a mejorarse

Como o aprendizaxe contrastante axuda a AI a mellorarse

対照的な学習がAIが自らを改善するのを助ける方法

Cum învățarea contrastantă ajută AI să se îmbunătățească

Как контрастное обучение помогает ИИ самосовершенствовать

1. Introduction Any deep learning model needs to have some sort of numeric input to work with. In computer vision its not a problem as we have pixel values as inputs but in Natural language processing we have text which is not a numeric input. One common way to convert text to numbers is to use one-hot representation. For example, let’s say we have a 10,000-word vocabulary, so any word can be represented by a vector of length 10,000 with 0’s everywhere except a one ‘1’ in words position in vocabulary. 2. Problem with One-Hot Encoding The problem with One-Hot encoding is that the vector will be all zeros except one unique index for each word as shown above in fig 1. Representing words in this way leads to substantial data sparsity and usually means that we may need more data in order to successfully train statistical models. Apart from the above issue, the main problem is of identifying similar words using one-hot encoding vectors. Let’s see what I mean by this with help of 2 sentences. Examples are from Deep learning specialization - Coursera. Examples are from Deep learning specialization - Coursera. Let’s say we have a trained language model and one of the training examples is I want a glass of orange Juice. This language model can easily predict Juice as the last word by looking at the word orange. Let’s say our language model never seen the word apple before. So, When our language model encounters the sentence I want a glass of apple to predict the next word, it will be able to predict the word Juice if representations for both words orange and apple are similar. But in our case using one-hot representation relation between apple and orange is not any closer(similar) as the relationship between any of the words a or an or zebra etc. It’s because the dot product between any 2 different one-hot vectors is zero. So it doesn’t know that apple and orange are much more similar than let’s say apple and an or apple and king. But the point is apple and orange are fruits and the representations for these should be similar. I want a glass of orange Juice Juice orange apple I want a glass of apple Juice orange apple a an zebra apple orange apple an apple king apple orange So, we want semantically similar words to be mapped to nearby points, thus making the representation carry useful information about the word’s actual meaning. We call this new representation Word Embeddings. Word Embeddings 3. Word Embeddings helps Transfer Learning As we have seen above in the example, even though our training data for language modeling does not have the word apple, if representation for apple is similar to the word orange (both are fruits so we expect most of the characteristics of them are same, so similar representation) then our language model is more probable to predict next word as juice in sentence I want a glass of apple. apple apple orange juice I want a glass of apple 4. How Word Embeddings Look Word embeddings are continuous, vector space representations of words. Word embedding vectors usually have dimensions around 300(in general embed_size). So each word in the vocabulary is represented by a vector of size 300. But what does each value of this vector of embed_size represent? We can think of them as representing certain characteristics like age, food, gender, size, royal, etc. Let’s go through an example to understand this in detail. Even though the below example shows that embeddings are represented by characteristics like age, food, gender, etc., embeddings which we learn won’t have an easy interpretation like component one is age, component two is food, etc., Important point to understand is that embeddings learn certain characteristics which will be very similar for similar words and different for dissimilar words. age food Important point to understand is that embeddings learn certain characteristics which will be very similar for similar words and different for dissimilar words. If we look at word embeddings of words Apple and orange, they look almost identical. So dot product of these two vectors would be high. Apple orange Now that we have a decent understanding of word embeddings, let’s see how we can produce these vectors of embed_size size for every word in the vocabulary. 5. Generating Word Embeddings: I will go over one of the earliest architectures. Below is the architecture we will go through. Currently Word Embeddings are learned as part of training process Word2Vec Skip-Gram model Word2Vec Skip-Gram model 6. Word2Vec Skip-Gram Model The main idea behind the Word2Vec Skip-Gram model is that words that show up in similar context will have similar representation. Context = Words that are likely to appear around them. Let’s understand this with an example: I play cricket every alternate day


Children are playing football across the street


Doctor advised me to play tennis every morning. I play cricket every alternate day I play cricket every alternate day Children are playing football across the street Children are playing football across the street Doctor advised me to play tennis every morning. Doctor advised me to play tennis every morning. Above, if we see words cricket, football and tennis all have the word play surrounding them(similar context). So these 3 words will have similar word embedding vectors which are justifiable as these 3 words are names of the sport. For any word, we can think of context as surrounding words. So our task is to predict a randomly selected surrounding word from the word of interest. Let’s understand this with an example Children are playing football across the street. Let’s pick our word of interest as the word football and playing as the surrounding word. So we give word football to our neural network(which we are going to train and build) and this neural network should predict with high probability the word playing. But context can include surrounding words that come before and also after and not just one word. So authors of paper used window size to select surrounding context words as shown below. Children are playing football across the street football playing football playing paper Model architecture Below is the model architecture we will be using Each training input as shown in fig 3 will be first represented as one-hot vectors that go in to model as shown in fig 4. Then we have an embedding layer with the number of neurons = embed_size(usually this is set to 300) and the output layer will be 10,000 neurons softmax(here vocabulary size = 10,000) that outputs the probability of each word in the vocabulary. For example, when the word football is sent as input to the trained Word2Vec model above, then the final layer will output high probabilities for the words are, playing, across, the as these are output words for input football in the training set. football are playing across the football Model is trained like any other neural network where we update coefficients using backpropagation and loss function. Hidden layer The hidden layer is where all the magic happens. The coefficients of this hidden layer are the actual word embeddings. For example, let’s say we are learning word embeddings of dimension 300 for every word. Then coefficients or weight matrix of hidden embedding layer will be of size 10000(vocab_size) X 300(embed_size). The output of the hidden layer will be of size 300(embed_size) X 1. This output will pass through the output layer with softmax to generate 10000 values. Instead of matrix multiplication, as shown above, we can directly use embedding weight matrix as a look-up table. Each row in the embedding weight matrix gives an embedding vector for a word(the result would be the same) in the vocabulary. Intuition As we have seen above, the main idea behind the Word2Vec Skip-Gram model is that Words that show up in similar context will have similar representation Words that show up in similar context will have similar representation So if two words have similar context(i.e., same words surrounding them) then our model needs to output similar output for these 2 words. For example, in our 3 sentences, the words cricket, football, tennis have similar context as the word playing is the surrounding word. Generally speaking, if we take large text corpora there is a very high chance that these 3 words(cricket, football, tennis) will have playing as a surrounding word. So our model has to output playingas output with a higher probability for these 3 words. This can only happen if embedding vectors for these 3 words are similar because embedding vectors are the ones that go into the output softmax layer as shown in Fig 4. cricket football tennis playing playing playing

Your AI Can’t Understand Language Until It Learns This Trick

Fraud Detection Using Artificial Intelligence and Machine Learning

I spent 400 Euros with Cursor in a couple of days… and these are my lessons learned. Building software with Cursor is super fast, and you should definitely use it. However, there are some downsides. AI can fail to keep your code consistent and can introduce vulnerabilities into your application. So these are my tips: Don't use "Free" or "Premium" models. Coding with them is like coding with a "junior programmer." As I like to say, a junior programmer is the most expensive programmer in a company—the result of their work is spaghetti code that somehow works, but nobody wants to touch it again, and everything needs to be refactored. The exception is the use of gpt-4o if you want to include an image in your request (for example, if you have a design that you would like to build).
The most expensive model is chatGPT 4.5-preview (costs 2 Euros per request via Cursor). However, at the moment of writing this blog, the performance is not worht it. Don't use it; don't waste your money.
Use the o1 model. It's not included in Free or Premium models; you need to allow it in Cursor account settings under "Enable usage-based pricing." If used via Cursor, it costs 40 cents per request. Is it expensive? It depends on how much you charge. If you save 15 minutes with such a request, how much did you actually earn?
Use your own API key for OpenAI. It is much cheaper. Moreover, there is a promo on the OpenAI platform where you get 10 million tokens daily for free if you share data with them—so you can pretty much build anything for free. (Available until April 30th, 2025, for some users.)
Allow a large context—requests will use more tokens, but it's worth it for better results and better consistency. In Cursor, go to Settings → Features → Chat & Composer.
Use default instructions (Rules for AI and Project rules in Cursor settings). Once you decide to use a library, add it to the default instructions. For example, if you decide to use HeroIcons, add it to your context. Otherwise, you might end up sometimes using lucide-icon, sometimes HeroIcons, and sometimes it creates an entire SVG icon from scratch.
Use a reference file to help with consistency. If you have one API endpoint ready and you're going to build another one, provide the existing file as a reference. For example, "Create a CRUD API endpoint for resources using the similar approach as in projects/routes." This helps maintain consistency.
Do the PR review. Sometimes it removes important parts; sometimes it introduces vulnerabilities. For now, you shouldn't use Cursor for complex projects with user data stored if you have no idea what you are doing.
Don't use paid or brand-new libraries. This makes sense if you think about it: AI is trained on available data, and there is much more vanilla JavaScript in public repos than use-cases for some paid libraries. Also, documentation is often not sufficient and can be unclear even to humans. However, you can build pretty much anything very fast with vanilla code.
Focus on providing the right context. This is pretty obvious, but it's actually crucial—if the context is incorrect, AI will try to fix the wrong issue. If you struggle to fix or build something, reconsider your context and try again. Don't use "Free" or "Premium" models. Coding with them is like coding with a "junior programmer." As I like to say, a junior programmer is the most expensive programmer in a company—the result of their work is spaghetti code that somehow works, but nobody wants to touch it again, and everything needs to be refactored. The exception is the use of gpt-4o if you want to include an image in your request (for example, if you have a design that you would like to build). Don't use "Free" or "Premium" models. The most expensive model is chatGPT 4.5-preview (costs 2 Euros per request via Cursor). However, at the moment of writing this blog, the performance is not worht it. Don't use it; don't waste your money. The most expensive model is chatGPT 4.5-preview Use the o1 model. It's not included in Free or Premium models; you need to allow it in Cursor account settings under "Enable usage-based pricing." If used via Cursor, it costs 40 cents per request. Is it expensive? It depends on how much you charge. If you save 15 minutes with such a request, how much did you actually earn? Use the o1 model. Use your own API key for OpenAI. It is much cheaper. Moreover, there is a promo on the OpenAI platform where you get 10 million tokens daily for free if you share data with them—so you can pretty much build anything for free. (Available until April 30th, 2025, for some users.) Use your own API key for OpenAI. Allow a large context—requests will use more tokens, but it's worth it for better results and better consistency. In Cursor, go to Settings → Features → Chat & Composer. Allow a large context Use default instructions (Rules for AI and Project rules in Cursor settings). Once you decide to use a library, add it to the default instructions. For example, if you decide to use HeroIcons, add it to your context. Otherwise, you might end up sometimes using lucide-icon, sometimes HeroIcons, and sometimes it creates an entire SVG icon from scratch. Use default instructions Use a reference file to help with consistency. If you have one API endpoint ready and you're going to build another one, provide the existing file as a reference. For example, "Create a CRUD API endpoint for resources using the similar approach as in projects/routes." This helps maintain consistency. Use a reference file to help with consistency. Do the PR review. Sometimes it removes important parts; sometimes it introduces vulnerabilities. For now, you shouldn't use Cursor for complex projects with user data stored if you have no idea what you are doing. Do the PR review. Don't use paid or brand-new libraries. This makes sense if you think about it: AI is trained on available data, and there is much more vanilla JavaScript in public repos than use-cases for some paid libraries. Also, documentation is often not sufficient and can be unclear even to humans. However, you can build pretty much anything very fast with vanilla code. Don't use paid or brand-new libraries. Focus on providing the right context. This is pretty obvious, but it's actually crucial—if the context is incorrect, AI will try to fix the wrong issue. If you struggle to fix or build something, reconsider your context and try again. Focus on providing the right context. I built my micro SaaS, in a couple of days with Cursor. Curious about results? Check out my profile for link.

I Blew €400 on Cursor — Here's What I Learned So You Don't Have To

"Cursor"da 400 dollar qazandım - burada nə öyrədim ki, sizə lazım olmayacaq

I Blew €400 en Cursor - Aquí es lo que aprendí para que no tengas que

I Blew €400 on Cursor - Here's What I Learned So You Don't Have

I Blew € 400 on Cursor - აქ არის ის, რაც მე გაიგო, ასე რომ თქვენ არ უნდა

I Blew € 400 ant kursoriaus - štai ką aš sužinojau, kad jums nereikėtų

Saya Blew € 400 pada Cursor - Inilah Yang Saya Pelajari Jadi Anda Tidak Perlu

I Blew €400 no cursor - aqui está o que eu aprendi para que você não precise

I Blew €400 на курсоре — вот что я узнал, так что вам не нужно

Био сам 400 евра на курсору - Ево шта сам научио тако да не морате

Cursor'da 400 Euro'ya Düştüm - İşte Öğrendiklerim

Authors:
(1) Rohit Saxena, Institute for Language, Cognition and Computation, School of Informatics, University of Edinburg;
(2) RFrank Keller, Institute for Language, Cognition and Computation, School of Informatics, University of Edinburg. Table of Links Part 1 Part 2 Part 3 Part 4 Part 5 Part 6 Abstract Abstractive summarization for long-form narrative texts such as movie scripts is challenging due to the computational and memory constraints of current language models. A movie script typically comprises a large number of scenes; however, only a fraction of these scenes are salient, i.e., important for understanding the overall narrative. The salience of a scene can be operationalized by considering it as salient if it is mentioned in the summary. Automatically identifying salient scenes is difficult due to the lack of suitable datasets. In this work, we introduce a scene saliency dataset that consists of human-annotated salient scenes for 100 movies. We propose a two-stage abstractive summarization approach which first identifies the salient scenes in script and then generates a summary using only those scenes. Using QA-based evaluation, we show that our model outperforms previous state-of-the-art summarization methods and reflects the information content of a movie more accurately than a model that takes the whole movie script as input.[1] 1. Introduction Abstractive summarization is the process of reducing an information source to its most important content by generating a coherent summary. Previous work has primarily focused on news (Cheng and Lapata, 2016; Gehrmann et al., 2018), meetings (Zhong et al., 2021), and dialogues (Zhong et al., 2022; Zhu et al., 2021a), but there is limited prior work on summarizing long-form narrative texts such as movie scripts (Gorinski and Lapata, 2015; Chen et al., 2022). Long-form narrative summarization poses challenges to large language models (Beltagy et al., 2020; Zhang et al., 2020a; Huang et al., 2021) both in terms of memory complexity and in terms of attending to salient information in the text. Large language models perform poorly for long sequence lengths in zero-shot settings compared to finetuned models (Shaham et al., 2023). Recently, Liu et al. (2024) showed that the performance of these models degrades when the relevant information is present in the middle of a long document. With an average length of 110 pages, movie scripts are therefore challenging to summarize. Several methods have previously relied on content selection for summarization to reduce the input size by either performing content selection implicitly using neural network attention (Chen and Bansal, 2018; You et al., 2019; Zhong et al., 2021) or explicitly (Ladhak et al., 2020; Manakul and Gales, 2021; Zhang et al., 2022) by aligning the source document with the summary using metrics such as ROUGE (Lin, 2004). Unlike for news articles, the implicit attention-based method is problematic for movie scripts, as current methods cannot reliably process text of such length. On the other hand, current explicit methods are neither optimized nor evaluated for content selection using gold-standard labels. In addition, considering the large number of sentences in movies that contain repeated mentions of characters and locations, a method based on a lexical overlap metric such as ROUGE creates many false positives. Crucially, all these methods use source–summary alignment as an auxiliary task without actually optimizing or evaluating this task. For news summarization, Ernst et al. (2021) created crowd-sourced development and test sets for the evaluation of proposition-level alignment. However, news texts differ from movie scripts both in length and in terms of the rigid inverted pyramid structure that is typical for news articles. For movie scripts, Mirza et al. (2021) proposed a specialized alignment method which they evaluated on a set of 10 movies. However, they do not perform movie script summarization. Movie scripts are structured in terms of scenes, where each scene describes a distinct plot element and hapening at a fixed place and time, and involving a fixed set of characters. It therefore makes sense to formalize movie summarization as the identification of the most salient scenes from a movie, followed by the generation of an abstractive summary of those scenes (Gorinski and Lapata, 2015). Hence we define movie scene saliency based on whether the scene is mentioned in the summary i.e., if the scene is mentioned in the summary, it is considered salient. Using scene saliency for summarization is therefore a method of explicit content selection. In this paper, we first introduce MENSA, a Movie ScENe SAliency dataset that includes human annotation of salient scenes in movie scripts. Our annotators manually align Wikipedia summary sentences with movie scenes for 100 movies. We use these gold-standard annotations to evaluate existing explicit alignment methods. We then propose a supervised scene saliency classification model to identify salient scenes given a movie script. Specifically, we use the alignment method that performs best on the gold-standard data to generate silverstandard labels on a larger dataset, on which we then train a sequence classification model using scene embeddings to identify salient scenes. We then fine-tune a pre-trained language model using only the salient scenes to generate movie summaries. This model achieves new state-of-the-art summarization results as measured by ROUGE and BERTScore (Zhang et al., 2020b). In addition to that, we evaluate the generated summaries using a question-answer-based metric (Deutsch et al., 2021) and show that summaries generated using only the salient scenes outperform those generated using the entire movie script or baseline models. 2. Related Work 2.1 Long-form Summarization Summarization of long-form documents has been studied across various domains, such as news articles (Zhu et al., 2021b), books (Kryscinski et al., 2022), dialogues (Zhong et al., 2022), meetings (Zhong et al., 2021), and scientific publications (Cohan et al., 2018). To handle and process the long documents, many efficient transformer variants have been proposed (Zaheer et al., 2020; Zhang et al., 2020a; Huang et al., 2021). Similarly, work such as Longformer (Beltagy et al., 2020) uses local and global attention in transformers (Vaswani et al., 2017) to process long inputs. However, given that movie scripts are particularly long (see Table 1), these models still have a limited capacity due to memory and time complexity, and need to truncate movie scripts based on the maximum sequence length supported by the model. Over the past decade, numerous approaches movie summarization have been proposed. Gorinski and Lapata (2018, 2015) generate movie overviews using a graph-based model and create movie script summaries based on progression, diversity, and importance. In contrast, the aim of our work is to find salient scenes and use these for summarization. Papalampidi et al. (2019, 2021) summarize movie scripts by identifying turning points, important narrative events. In contrast, our approach is based on salient scenes and does not assume a rigid narrative structure. Recently, Agarwal et al. (2022) proposed a shared task for script summarization; the best model (Pu et al., 2022) used a heuristic approach to truncate the script. 2.2 Summarization based on Content Selection Several methods (Ladhak et al., 2020; Manakul and Gales, 2021; Liu et al., 2022) have leveraged content selection for summarization. Chen and Bansal (2018) and Zhang et al. (2022) generate silver standard labels through greedy alignment of the source document sentences with summary sentences. However, these methods do not explicitly evaluate alignments. Moreover, movie scripts consist of a large number of sentences with the same characters and location names, which can generate many false positives in greedy alignment. We collect gold-standard saliency labels to compare and evaluate alignment methods. Mirza et al. (2021) proposed a movie script alignment method for summaries but do not actually propose a summarization model. Recent work (Dou et al., 2021; Wang et al., 2022) has employed neural network attention for the summarization of short documents. However, movie scripts are challenging for attention-based methods, given their length. This paper is available on arxiv under CC BY 4.0 DEED license. [1] Our dataset and code is released at https://github.com/saxenarohit/select_summ. Authors: (1) Rohit Saxena, Institute for Language, Cognition and Computation, School of Informatics, University of Edinburg; (2) RFrank Keller, Institute for Language, Cognition and Computation, School of Informatics, University of Edinburg. Authors: Authors: (1) Rohit Saxena, Institute for Language, Cognition and Computation, School of Informatics, University of Edinburg; (2) RFrank Keller, Institute for Language, Cognition and Computation, School of Informatics, University of Edinburg. Table of Links Part 1 Part 1 Part 2 Part 2 Part 3 Part 3 Part 4 Part 4 Part 5 Part 5 Part 6 Part 6 Abstract Abstractive summarization for long-form narrative texts such as movie scripts is challenging due to the computational and memory constraints of current language models. A movie script typically comprises a large number of scenes; however, only a fraction of these scenes are salient, i.e., important for understanding the overall narrative. The salience of a scene can be operationalized by considering it as salient if it is mentioned in the summary. Automatically identifying salient scenes is difficult due to the lack of suitable datasets. In this work, we introduce a scene saliency dataset that consists of human-annotated salient scenes for 100 movies. We propose a two-stage abstractive summarization approach which first identifies the salient scenes in script and then generates a summary using only those scenes. Using QA-based evaluation, we show that our model outperforms previous state-of-the-art summarization methods and reflects the information content of a movie more accurately than a model that takes the whole movie script as input.[1] 1. Introduction Abstractive summarization is the process of reducing an information source to its most important content by generating a coherent summary. Previous work has primarily focused on news (Cheng and Lapata, 2016; Gehrmann et al., 2018), meetings (Zhong et al., 2021), and dialogues (Zhong et al., 2022; Zhu et al., 2021a), but there is limited prior work on summarizing long-form narrative texts such as movie scripts (Gorinski and Lapata, 2015; Chen et al., 2022). Long-form narrative summarization poses challenges to large language models (Beltagy et al., 2020; Zhang et al., 2020a; Huang et al., 2021) both in terms of memory complexity and in terms of attending to salient information in the text. Large language models perform poorly for long sequence lengths in zero-shot settings compared to finetuned models (Shaham et al., 2023). Recently, Liu et al. (2024) showed that the performance of these models degrades when the relevant information is present in the middle of a long document. With an average length of 110 pages, movie scripts are therefore challenging to summarize. Several methods have previously relied on content selection for summarization to reduce the input size by either performing content selection implicitly using neural network attention (Chen and Bansal, 2018; You et al., 2019; Zhong et al., 2021) or explicitly (Ladhak et al., 2020; Manakul and Gales, 2021; Zhang et al., 2022) by aligning the source document with the summary using metrics such as ROUGE (Lin, 2004). Unlike for news articles, the implicit attention-based method is problematic for movie scripts, as current methods cannot reliably process text of such length. On the other hand, current explicit methods are neither optimized nor evaluated for content selection using gold-standard labels. In addition, considering the large number of sentences in movies that contain repeated mentions of characters and locations, a method based on a lexical overlap metric such as ROUGE creates many false positives. Crucially, all these methods use source–summary alignment as an auxiliary task without actually optimizing or evaluating this task. For news summarization, Ernst et al. (2021) created crowd-sourced development and test sets for the evaluation of proposition-level alignment. However, news texts differ from movie scripts both in length and in terms of the rigid inverted pyramid structure that is typical for news articles. For movie scripts, Mirza et al. (2021) proposed a specialized alignment method which they evaluated on a set of 10 movies. However, they do not perform movie script summarization. Movie scripts are structured in terms of scenes, where each scene describes a distinct plot element and hapening at a fixed place and time, and involving a fixed set of characters. It therefore makes sense to formalize movie summarization as the identification of the most salient scenes from a movie, followed by the generation of an abstractive summary of those scenes (Gorinski and Lapata, 2015). Hence we define movie scene saliency based on whether the scene is mentioned in the summary i.e., if the scene is mentioned in the summary, it is considered salient. Using scene saliency for summarization is therefore a method of explicit content selection. In this paper, we first introduce MENSA, a M ovie S c EN e SA liency dataset that includes human annotation of salient scenes in movie scripts. Our annotators manually align Wikipedia summary sentences with movie scenes for 100 movies. We use these gold-standard annotations to evaluate existing explicit alignment methods. We then propose a supervised scene saliency classification model to identify salient scenes given a movie script. Specifically, we use the alignment method that performs best on the gold-standard data to generate silverstandard labels on a larger dataset, on which we then train a sequence classification model using scene embeddings to identify salient scenes. We then fine-tune a pre-trained language model using only the salient scenes to generate movie summaries. This model achieves new state-of-the-art summarization results as measured by ROUGE and BERTScore (Zhang et al., 2020b). In addition to that, we evaluate the generated summaries using a question-answer-based metric (Deutsch et al., 2021) and show that summaries generated using only the salient scenes outperform those generated using the entire movie script or baseline models. M S EN SA 2. Related Work 2.1 Long-form Summarization Summarization of long-form documents has been studied across various domains, such as news articles (Zhu et al., 2021b), books (Kryscinski et al., 2022), dialogues (Zhong et al., 2022), meetings (Zhong et al., 2021), and scientific publications (Cohan et al., 2018). To handle and process the long documents, many efficient transformer variants have been proposed (Zaheer et al., 2020; Zhang et al., 2020a; Huang et al., 2021). Similarly, work such as Longformer (Beltagy et al., 2020) uses local and global attention in transformers (Vaswani et al., 2017) to process long inputs. However, given that movie scripts are particularly long (see Table 1), these models still have a limited capacity due to memory and time complexity, and need to truncate movie scripts based on the maximum sequence length supported by the model. Over the past decade, numerous approaches movie summarization have been proposed. Gorinski and Lapata (2018, 2015) generate movie overviews using a graph-based model and create movie script summaries based on progression, diversity, and importance. In contrast, the aim of our work is to find salient scenes and use these for summarization. Papalampidi et al. (2019, 2021) summarize movie scripts by identifying turning points, important narrative events. In contrast, our approach is based on salient scenes and does not assume a rigid narrative structure. Recently, Agarwal et al. (2022) proposed a shared task for script summarization; the best model (Pu et al., 2022) used a heuristic approach to truncate the script. 2.2 Summarization based on Content Selection Several methods (Ladhak et al., 2020; Manakul and Gales, 2021; Liu et al., 2022) have leveraged content selection for summarization. Chen and Bansal (2018) and Zhang et al. (2022) generate silver standard labels through greedy alignment of the source document sentences with summary sentences. However, these methods do not explicitly evaluate alignments. Moreover, movie scripts consist of a large number of sentences with the same characters and location names, which can generate many false positives in greedy alignment. We collect gold-standard saliency labels to compare and evaluate alignment methods. Mirza et al. (2021) proposed a movie script alignment method for summaries but do not actually propose a summarization model. Recent work (Dou et al., 2021; Wang et al., 2022) has employed neural network attention for the summarization of short documents. However, movie scripts are challenging for attention-based methods, given their length. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv [1] Our dataset and code is released at https://github.com/saxenarohit/select_summ.

How AI Learns to Summarize Movies Like a Human

Why Our Prototype-based AI Beats Traditional Concept Learning Approaches

Authors:
(1) M. Carrasco, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay (carrasco_m@ort.edu.uy);
(2) F. Mayr, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay (mayr@ort.edu.uy);
(3) S. Yovine, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay (yovine@ort.edu.uy);
(4) J. Kidd, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay;
(5) M. Iturbide, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay;
(6) J. da Silva, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay;
(7) A. Garat, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay. Authors: Authors: (1) M. Carrasco, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay (carrasco_m@ort.edu.uy); (2) F. Mayr, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay (mayr@ort.edu.uy); (3) S. Yovine, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay (yovine@ort.edu.uy); (4) J. Kidd, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay; (5) M. Iturbide, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay; (6) J. da Silva, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay; (7) A. Garat, Facultad de Ingenierıa, Universidad ORT Uruguay, Montevideo, Uruguay. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Language models 2 Language models 3 Learning algorithm 3 Learning algorithm 4 Analyzing large language models 4 Analyzing large language models 5 Conclusions. Acknowledgements, and References 5 Conclusions. Acknowledgements, and References A. Proof of Proposition 2.1 A. Proof of Proposition 2.1 B. Proof of Proposition 2.2 B. Proof of Proposition 2.2 C. Proof of Proposition 2.3 C. Proof of Proposition 2.3 D. Proof of Proposition 2.4 D. Proof of Proposition 2.4 3 Learning algorithm Performance experiments We compare Omit-Zero against two instances of QNT, varying the behavior of the teacher: Standard uses Hopcroft-Karp algorithm [3] as EQ and MQ as in [6], while Teacher-Filter checks if the string being queried by MQ traverses a 0-probability transition, in which case it identifies it as undefined. Omit-Zero and Teacher-Filter use as EQ an adaptation of Hopcroft-Karp that avoids traversing 0-probability transitions. The comparison is done by randomly generating PDFA. First, we construct DFA using the algorithm in [9], which for a given nominal size of n it generates DFA of actual reachable size normally distributed around n. Then, DFA are transformed into PDFA by assigning a random probability distribution over Σ$ to every state. A parameter θ is used to control the probability of a symbol to be 0. Performance experiments Omit-Zero Standard EQ MQ Teacher-Filter Omit-Zero Running times as function of θ. 10 random PDFA with n = 500 and |Σ| = m = 20 were generated for each θ ∈ [0.9, 1), with step 0.02. Each one was run 10 times for every PDFA using quantization equivalence ([6]), adapted to satisfy (3), with parameter κ = 100. Fig. 3(a) shows Omit-Zero has the best performance, with an almost constant but important improvement with respect to Teacher-Filter. Running times as function of Omit-Zero Teacher-Filter. Running times as function of n. We compared the performance on 10 random PDFA with n = 250, 500, 750, 1000, and m = 10, using κ = 10 and θ = 0.9. Each algorithm was run 10 times for each PDFA. Fig. 3(b) shows the median of the execution time curves for n. Omit-Zero is always faster than the other two, achieving a speedup of approximately 24x and 3x with respect to Standard and Teacher-Filter, respectively, for n = 1000. Running times as function of Omit-Zero Standard Teacher-Filter, 4 Analyzing large language models Guiding generation Guiding an LLM to generate strings of interest consists in synchronizing it with a automaton that defines the set of symbols that can be drawn at each step of the generation process, which could be constrained further by a sampling strategy. To illustrate how the synchronization works, consider the language model given by the PDFA L in Fig. 4 (0-probabilities are omitted). The guide G is a weighted automaton that defines a mask at each state: a weight of 1 for a symbol means it is allowed, otherwise it is not. L × G is a weighted automaton whose underlying structure is the product automaton, and weights are obtained by taking the product of the distribution of the state of L with the weights of the state of G. To obtain PDFA B, we apply the sampling strategy samptop2. 5 Conclusions This work was motivated by the need of understanding LLM when their operation is controlled by external artifacts, such as grammars, to generate text following a specific format. An important question that arise in this context is how to deal with 0-probabilities that appear when restricting their output. To start up with, we revised the congruence (1) in order to make constructing the quotient less dependent on P by expressing it in terms of the output of the language model. The first consequence of this operational view is to allow a generalization of the congruence capable of dealing with equivalences on distributions. Besides, it led to developing a variant of the QNT active-learning algorithm to efficiently learn PDFA by avoiding to check for 0-probability transitions as much as possible. This is essential to make it computationally feasible by reducing the number of queries to the LLM. The experimental results[3] support the viability of our approach for analyzing and validating statistical properties of LLM, such as bias in text generation. Besides, they provided evidence that distributions resulting from generation of a guided LLM could be well approximated by a learnt PDFA. This opens the door to make these analyses less dependent on sampling by studying properties of the PDFA. Acknowledgements Research reported in this article has been partially funded by ANII-Agencia Nacional de Investigacion e Innovaci ´ on under grants IA ´ 1 2022 1 173516, FMV 1 2023 1 175864, POS NAC 2023 1 178663, and POS FMV 2023 1 1012218. Acknowledgements References [1] R. C. Carrasco and J. Oncina. Learning deterministic regular grammars from stochastic samples in polynomial time. RAIRO - Theoretical Informatics and Applications, 33(1):1–19, 1999. [2] L. Du, L. Torroba Hennigen, T. Pimentel, C. Meister, J. Eisner, and R. Cotterell. A measure-theoretic characterization of tight language models. In 61st ACL, pages 9744–9770, July 2023. [3] J. E. Hopcroft and R. M. Karp. A linear algorithm for testing equivalence of finite automata. 1971. [4] I. Khmelnitsky, D. Neider, R. Roy, X. Xie, B. Barbot, B. Bollig, A. Finkel, S. Haddad, M. Leucker, and L. Ye. Property-directed verification and robustness certification of recurrent neural networks. In ATVA, pages 364–380, Cham, 2021. Springer International Publishing. [5] M. Kuchnik, V. Smith, and G. Amvrosiadis. Validating large language models with ReLM. In MLSys, 2023. [6] F. Mayr, S. Yovine, M. Carrasco, F. Pan, and F. Vilensky. A congruence-based approach to active automata learning from neural language models. In PMLR, volume 217, pages 250–264, 2023. [7] F. Mayr, S. Yovine, and R. Visca. Property checking with interpretable error characterization for recurrent neural networks. MAKE, 3(1):205–227, 2021. [8] E. Muskardin, M. Tappler, and B. K. Aichernig. Testing-based black-box extraction of simple models from rnns ˇ and transformers. In PMLR, volume 217, pages 291–294, 10–13 Jul 2023. [9] C. Nicaud. Random deterministic automata. In MFCS’14, pages 5–23. LNCS 8634, 2014. [10] P. C. Shields. The ergodic theory of discrete sample paths. AMS, 1996. [11] E. Vidal, F. Thollard, C. de la Higuera, F. Casacuberta, and R.C. Carrasco. Probabilistic finite-state machines - part i. IEEE PAMI, 27(7):1013–1025, 2005. [12] Q. Wang, K. Zhang, A. G. Ororbia, II, X. Xing, X. Liu, and C. L. Giles. An empirical evaluation of rule extraction from recurrent neural networks. Neural Comput., 30(9):2568–2591, 2018. [13] G. Weiss, Y. Goldberg, and E. Yahav. Extracting automata from recurrent neural networks using queries and counterexamples. In PMLR, volume 80, 10–15 Jul 2018. [14] B. T. Willard and R. Louf. Efficient guided generation for LLMs. Preprint arXiv:2307.09702, 2023. A Proof of Proposition 2.1 Proof. Let u and v in Σ ∗ be arbitrary. Proof B Proof of Proposition 2.2 C Proof of Proposition 2.3 D Proof of Proposition 2.4 This paper is available on arxiv under CC BY-SA 4.0 by Deed (Attribution-Sharealike 4.0 International) license. This paper is available on arxiv under CC BY-SA 4.0 by Deed (Attribution-Sharealike 4.0 International) license. available on arxiv available on arxiv [2] https://huggingface.co/docs/transformers/main_classes/tokenizer https://huggingface.co/docs/transformers/main_classes/tokenizer [3] https://github.com/neuralchecker/analyzing_constrained_LLM_through_PDFA_learning https://github.com/neuralchecker/analyzing_constrained_LLM_through_PDFA_learning

Zero Isn’t a Problem, It’s a Shortcut: Rethinking PDFA Learning

One Decision Tree Is a Risk—A Forest? That’s Smart Machine Learning

Authors:
(1) Sanchit Sinha, University of Virginia (sanchit@virginia.edu);
(2) Guangzhi Xiong, University of Virginia (hhu4zu@virginia.edu);
(3) Aidong Zhang, University of Virginia (aidong@virginia.edu). Authors: Authors: (1) Sanchit Sinha, University of Virginia (sanchit@virginia.edu); (2) Guangzhi Xiong, University of Virginia (hhu4zu@virginia.edu); (3) Aidong Zhang, University of Virginia (aidong@virginia.edu). Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Related Work 2 Related Work 3 Methodology and 3.1 Representative Concept Extraction 3 Methodology and 3.1 Representative Concept Extraction 3.2 Self-supervised Contrastive Concept Learning 3.2 Self-supervised Contrastive Concept Learning 3.3 Prototype-based Concept Grounding 3.3 Prototype-based Concept Grounding 3.4 End-to-end Composite Training 3.4 End-to-end Composite Training 4 Experiments and 4.1 Datasets and Networks 4 Experiments and 4.1 Datasets and Networks 4.2 Hyperparameter Settings 4.2 Hyperparameter Settings 4.3 Evaluation Metrics and 4.4 Generalization Results 4.3 Evaluation Metrics and 4.4 Generalization Results 4.5 Concept Fidelity and 4.6 Qualitative Visualization 4.5 Concept Fidelity and 4.6 Qualitative Visualization 5 Conclusion and References 5 Conclusion and References Appendix Appendix 3 Methodology In this section, we first provide a detailed description of our proposed learning pipeline, including (a) the Representative Concept Extraction (RCE) framework which incorporates a novel Salient Concept Selection Network in addition to the Concept and Relevance Networks, (b) Self-Supervised Contrastive Concept Learning (CCL) which enforces domain invariance among learned concepts, and (c) a Prototype-based Concept Grounding (PCG) regularizer that mitigates the problem of concept-shift among domains. We then provide details for the end-to-end training procedure with additional Concept Fidelity regularization which ensures concept consistency among similar samples. 3.1 Representative Concept Extraction 3.2 Self-supervised Contrastive Concept Learning Even though the RCE framework generates representative concepts, the concepts extracted are adulterated with domain noise thus limiting their generalization. In addition, with limited training data, the concept extraction process is not robust. Self-supervised learning contrastive training objectives are the most commonly used paradigm [Thota and Leontidis, 2021] for learning robust visual features in images. We incorporate self-supervised contrastive learning to learn domain invariant concepts, termed CCL. 3.3 Prototype-based Concept Grounding Concept Fidelity Regularization. Concept fidelity attempts to enforce the similarity of concepts through a similarity measure s(·, ·) of data instances from the same class in the same domain. Formally, Concept Fidelity Regularization. 3.4 End-to-end Composite Training Overall, the training objective can be formalized as a weighted sum of CCL and PCG objectives: where λ1 and λ2 are tunable hyperparameters controlling the strength of contrastive learning and prototype grounding regularization. The end-to-end training objective can be represented as: The tunable hyperparameter β controls the effect of generalization and robustness on the RCE framework. Note that a higher value of β makes the concept learning procedure brittle and unable to adapt to target domains. However, a very low value of β makes the concept learning procedure overfit on the source domain, implying a tradeoff between concept generalization and performance. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Stories, News & Mentions about LEAR

Categories

Trending Topics

Stories, News & Mentions about LEAR

Lear’s Stories on HackerNoon

Lear's News & Mentions

Categories

Trending Topics