update A bite of math

Adding pages and change the password function

app.py

@@ -1,14 +1,23 @@
 import streamlit as st
+import extra_streamlit_components as stx
+import spacy_streamlit
+import streamlit_book as stb
+
 
 st.set_page_config(
         page_title="Welcome to AI club",
         page_icon="👋",
     )
 
+def get_manager():
+    return stx.CookieManager()
+
+cookie_manager = get_manager()
+
+
 ## Page layout
 @st.cache_data
 def main_layout():
-    #st.sidebar.success("Select weekly task above.")
     st.markdown(
         """
         This is our weekly tutorial pages.
@@ -30,4 +39,6 @@ st.markdown("""
         - [Hugging Face HowTos](https://huggingface.co/docs/hub/spaces)
         - [Learn to ClickUp](https://help.clickup.com/hc/en-us/categories/5414365970455-Features)
         """
-        )
+        )
+
+

pages/11_A_Bite_Of_Maths.py

@@ -0,0 +1,16 @@
+## Just A bit of Maths
+import streamlit as st
+import streamlit_book as stb
+
+stb.set_book_config(
+                     menu_title="A bite of Maths",
+                     menu_icon="lightbulb",
+                     options=[
+                            "CH1: Learn from scratch",
+                            "CH2: Learn graduately"
+                            ], 
+                     paths=[
+                            "pages/pages/1_Learning_from_scratch.py",
+                            "pages/pages/2_Learning_graduately.py"
+                            ],
+                     )

pages/2_201_Text_summarisation_with_LLM.py

@@ -1,7 +1,7 @@
 import streamlit as st
 from utils import *
 
-if check_password():
+if check_password("password"):
     st.markdown("""
     ## With ChatGPT 
     

pages/2_202_Access_to_HuggingFace_with_Notebook.py

@@ -1,36 +1,7 @@
 import streamlit as st
 from utils import *
 
-def check_password():
-    """Returns `True` if the user had the correct password."""
-
-    def password_entered():
-        """Checks whether a password entered by the user is correct."""
-        if st.session_state["password"] == st.secrets["password"]:
-            st.session_state["password_correct"] = True
-            del st.session_state["password"]  # don't store password
-        else:
-            st.session_state["password_correct"] = False
-
-    if "password_correct" not in st.session_state:
-        # First run, show input for password.
-        st.text_input(
-            "Password", type="password", on_change=password_entered, key="password"
-        )
-        return False
-    elif not st.session_state["password_correct"]:
-        # Password not correct, show input + error.
-        st.text_input(
-            "Password", type="password", on_change=password_entered, key="password"
-        )
-        st.error("😕 Password incorrect")
-        return False
-    else:
-        # Password correct.
-        return True
-
-
-if check_password():
+if check_password("password"):
     st.markdown("""
     ## Notebook to Hugging Face Space
     
@@ -95,8 +66,16 @@ if check_password():
     ##### 5. Update your changes to the specific branch
     
     1. If you have edited the app.py file with your profile, the change already happened in your local code folder;
-    2. For simplicity, you will upload the updated folder "Tutorials" to the "week2" branch;
-    3. We will normally merge the two branches, "main" and weekly branch at the end of week, then the "main" file will have the change we made.
+    2. For simplicity, you will upload the updated folder "Tutorials" to the "main" branch;
+    
+    2.5. But before you commit change, you should **always** update your local code with newest change at our code space, by:
+    ```python
+    from huggingface_hub import Repository
+    repo = Repository(local_dir="<Your local folder>", clone_from="<The HF folder>", revision='main')
+    repo.git_pull(rebase=True) # This will update your local folder
+    ```
+    
+    3. We will check your commit and merge it mannualy from HF web interface
     
     Using the code snippet below to update your changes,
     - You will need to do detailed editing and check before you submit it, otherwise, your pull request would not be accepted
@@ -105,7 +84,7 @@ if check_password():
     api.upload_folder(folder_path="./Tutorials", # the folder path at the local machine
                       repo_id="TGSAI/Tutorials",
                       repo_type="space",
-                      revision = 'week2', # make sure upload to the weekly branch
+                      revision = 'main', # make sure upload to the main branch
                       commit_message = 'https://app.clickup.com/t/860r79ppd', # add comment, mostly link to Clickup ticket url
                       commit_description = '', # any discription, or omitted
                       create_pr = True # Important! You must create Pull Request, then the maintainer will need to check it.

pages/3_301_Running_streamlit_locally.py

@@ -1,7 +1,7 @@
 import streamlit as st
 from utils import *
 
-if check_password():
+if check_password("password"):
     st.markdown("""
     ## Set up local streamlit 
     

pages/3_302_Our_First_App.py

@@ -2,7 +2,7 @@ import streamlit as st
 from utils import *
 st.set_page_config(page_title="The first App", page_icon=":tangerine:")
 
-if check_password():
+if check_password("password"):
     st.markdown("## Welcome to the first app: summarizer")
     st.write("##")
     

pages/pages/1_Learning_from_scratch.py

@@ -0,0 +1,182 @@
+## Maths -- 1_learning from scratch.py
+
+import streamlit as st
+
+
+st.markdown("""
+#### **Chapter 1. Predict from scratch, who cares about mistakes :smiling_imp:**
+    
+##### 1.1 We will start from an simple prediction task,
+
+> **Example forever**
+> 
+> You are going to predict the price of a house from a selection of the following factors:
+> - Living areas (on $m^2$)
+> - Number of bedrooms
+> - Number of garages
+> - Number of bathsroom
+> - nabourhood average income?
+> - some other factors
+
+The factors above are just a simplified example of all posible factors when people considering or predicting house prices. Different people might have different choices. Some people might only have one factor, such as, whether it is "good-looking" or not; where as others might have very complicated model that considering a lot of factors. **But for now**, we just use two factors that I believe it will be correct for predicting house price, and you will have nowhere to argue about this with me, just take it. The two factors are `"Living areas"` and `"Number of bedrooms"`, let's go!
+""")
+
+st.markdown("""
+> **1.2 My stupid prediction initially**
+
+> I am extremely stupid and has no idea what to do with this prediction, so I just grab whatever numbers in my head. I believe that the price per living area should be $ 100\ per\ m^2$, and the price per number of bedroom should be $ 5000\ per\ badroom$ So I made my prediction to an Algebraic equation: 
+""")
+st.latex(r'''
+    Price = area \times 100\ + NumberOfBedroom \times 5000
+    ''')
+
+st.markdown("""
+So based on my assumption, a 3 bedrooms house with $120 m^2$ of living area would cost: """)
+st.latex(r'''
+    120 \times 100 + 3 \times 5000 = 27000
+    ''')
+
+st.markdown("""
+Of course, my model is far from being accurate. But how can I **learn** to make it more accurate? I will learn it by collecting some information of houses sold like the table below:
+
+| # Bedrooms | Living area | Sold Price |
+| -----------| ----------- | ---------- |
+| 4          | 170         | 1,200,000  |
+| 3          | 130         | 980,000    |
+| 5          | 230         | 1,600,000  |
+| ......     | ......      | ......     |
+
+""")
+
+st.markdown("""
+Then, I will formally "define" what I have done so far. The two factors I choosed, I will call them **variables**. The number from my stupid guess, which means, $5000$ and $100$, I will call them **weights** of each variable. So for example, 5000 is the weight of number of bedrooms, 100 is the weight of living area. Thus my model can be defined as:""")
+st.latex(r'''a \times weight_a + b \times weight_b = prediction''')
+st.write("in which:")
+st.latex(r'''a => Living\ areas; \ b=>Number\ of\ bedrooms ''')
+
+st.markdown("""
+One more thing I will do is to add my initial predictions to the table above. Let's see how stupid I was!
+
+
+| # Bedrooms | Living area | Sold Price | Myprediction|
+| ---------- | ----------- | ---------- | --- |
+| 4          | 170         | 1,200,000  |37000|
+| 3          | 130         | 980,000    |28000|
+| 5          | 230         | 1,600,000  |48000|
+| ......     | ......      | ......     |     |
+""")
+
+st.write("##")
+st.markdown("""   
+##### 1.2 Loss Functions: evaluate how bad my model is,
+
+Let's summarise what I have done so far. I creatd a function, for which I passed two sets of values to it:
+ 
+ - The first set of values is the value pair (Number of Bedroom, Living Area), Lets call this paired value *samples*, and write it in the form of $\Bbb{x} := (x_1, x_2)$, where $x_1$ is the Number of bedrooms and $x_2$ is the living area.
+ - The second set of values is the value pair (Weight1, Weight2), which is the weight for number of bedrooms and living area respectively. Let's call them just weights. 
+ 
+So my funciton is defined by, every time I give it two pairs, one pair of samples and one pair of weights, it give me the predicted house price. Writen in a math form: 
+""")
+st.latex(r'''f(\Bbb{x}, \Bbb{w}) := x_1\times w_1 + x_2\times w_2''')
+
+st.markdown("""
+Now I have collected 100 data points of houses, and I have done my naive prediction by passing the pair of samples 100 times to my model (my naive **Weights** doesn't change at this time), and I got 100 **wrong** predictions. Before I could improve myself, I need to know how bad I have just done in general. This can be done easily through *Calculating the average difference between sold-price and my prediction*, the larger the average difference (Let's call it **:red[Error]** from now on), the worse my model.
+
+But wait a munite, if I have two predictions, one is 10000 *above* the sold-price and another is 10000 *below* the sold-price, then the average would be Zero! I need a more reasonable feedback! We can handle this by squaring the errors:""")
+st.latex(r'''\frac{10000^2 + (-10000)^2}{2} = 100M''')
+
+st.markdown("""
+Now, we can define this "Averaging the squaring of the errors" as a function as well! Let's call it **Loss function**, denote by $L(f(\Bbb{x}, \Bbb{w}),\Bbb{y})$, where y is the sold-prices. A warm reminder for some reader is that you can understand $L(f(\Bbb{x}, \Bbb{w}),\Bbb{y})$ as $L(prediction, y)$ for simplicity, as $f(\Bbb{x}, \Bbb{w}) = prediction$. 
+
+Our purpose of learning, or model training, is to make our Loss smaller by updating weights, in a mathematical way of expression:
+""")
+st.latex(r'''\arg min_{\Bbb{w}\in \Bbb{R}^d}\ \ \ \frac{1}{l}\sum_{i=1}^{l}L(f(\Bbb{x_i}, \Bbb{w}),\Bbb{y})''')
+st.markdown("""
+Where $\Bbb{R}^d$ is the set of all possible pairs of weights, and d is the dimension of the weights, in our example, we call them pairs, it means $d = 2$, of cause there will be high dimensional weights, once our considered factors become more and more! $l$ is the number of samples (or the number of rows in the table above), just like the 100 in our example above.
+""")
+
+st.write("##")
+st.markdown("""   
+##### 1.3 Cool things about the loss function,
+
+One good thing about the loss function is "**convex**". Mathematically, convexity of a function: $f: \Bbb{R}^d \mapsto \Bbb{R}$ can be express as:
+""")
+st.latex(r'''f(tx + (1-t)y)\le tf(x) + (1-t)f(y);\ \forall x,y \in \Bbb{R}^d,\ t\in [0,1]''')
+st.markdown("""
+Let's forget about the symbols and look at a graph:""")
+
+st.image("https://i.ibb.co/KmzvqCz/Quodratic1.png", width=300,)
+st.markdown("""
+We will explain that Math expression with words and graph:
+
+- From words: Picking any two points for inputs, the outputs of these two points from the function can be connected by a straight line, so curve of the function between these two points will always below or match this straight line.
+
+- From Graph:
+""")
+st.image("https://i.ibb.co/D5LzPRT/Quodratic2.png", width=300,)
+st.markdown("""
+On the graph above, I randomly picked two points on the x-axis to generate two points on the curve, called A and B, connected them with a straight line, then all the function curve between the the range of two points on the x-axis would below or exactly match the line between A and B.This is the idea of convexity of a funciton. This helps us to answer the first question above, yes, the **:red[LOSS]** function does have a minimum (more specifically, due to convexity, a global minimum) for us to approach! Now, our second question:
+
+> How do we approach there?
+
+In general,we need to two pieces of information to achieve this, the direction of moving, and the magnitute of moving. Following the Graph above, we can demonstrate the idea through another graph:
+""")
+st.image("https://i.ibb.co/Jkkg1zz/Quodratic3.png", width=300,)
+st.markdown("""
+- Explain the graph:
+
+Let's say that our LOSS of the naive model is at D. We want our loss goes downs to the bottom of the curve, one way is to go to the direction as the black arrow showed. 
+
+This can be done by letting the target variable (i.e. the horizontal one, the input of the function) *goes to the negtive direction of the **[Gradient](https://thirdspacelearning.com/gcse-maths/algebra/gradient-of-a-line/)** of the **:red[LOSS]** function*, also attached with some magnitute of moving (i.e. controlled by the term, "learning rate"). 
+    
+After this, our new input of the **:red[LOSS]** function would become $A^{'}$, our new output of the **:red[LOSS]** function would become E, which is lower than D, as required.
+
+Now we know that:
+
+- there is a minimum of our LOSS function to approach
+- there is a way, we can approach the minumum
+
+But before we can moving toward implement our method, two more question I need to consider:
+
+- How can I be garanteed that, using the way provided here, I will eventually reach the minimum by finite number of steps?
+- What is the "learning rate"?
+
+We will answer the two questions together in the next section.
+
+""")
+
+with st.expander("Pass the quiz to get to the next section :)"):
+
+    st.markdown("To access to the next section, you have to finish the little test below: :smile:")
+    st.write("##")
+    st.markdown("Q1. If I have a 3-Bedrooms House with 140 $m^2$ of living area. If my weights of house price for the two variables is (1000, 2000) respectively. What would be my predicted house price based on the weights?")
+
+    q1 = st.radio("", ["A. 1.2 million", "B. 300k", "C. 283k", "D. 310k"])
+
+    st.write("##")
+    st.markdown("Q2. Following the Q1's context, if the true selling price for the house is 1.05 million, what is the error of my prediction?")
+
+    q2 = st.radio("", ["A. 1 million", "B. 750k", "C. 280k", "D. 767k"])
+
+    st.write("##")
+    st.markdown("Q3. For the function $ y = 2x^2 $, what is the gradient at $ x = -2 $?")
+
+    q3 = st.radio("", ["A. 8", "B. -8", "C. 4", "D. -4"])
+
+    st.write("##")
+    st.markdown("Q4. Following the Q3's context, if the learning rate is 0.0001, where my x should move to based on the Gradient Descent Algorithm?")
+
+    q4 = st.radio("", ["A. -1.9992", "B. 1.9992", "C. 0.0008", "D. -0.0008"])
+
+    st.write("##")
+    st.markdown("Q5. Is the linear function $ y = 3x - 8$ convex? ")
+
+    q5 = st.radio("", ["A. Yes", "B. No"])
+
+    if st.button("Try your luck..."):
+        if q1 == "C. 283k" and q2 == "D. 767k" and q3 == "B. -8" and q4 == "A. -1.9992" and q5 == "A. Yes":
+            st.write("Congratulations! The password for the next section is convexity. ")
+        else: 
+            st.write("Oop! Unlucky... You may try again!")
+
+

pages/pages/2_Learning_graduately.py

@@ -0,0 +1,143 @@
+import streamlit as st
+from utils import *
+
+if check_password("m2"):
+    st.markdown("""
+    #### **Chapter 2. By learning graduately, nothing can stop us :mechanical_arm:**
+
+    \n
+    \n
+
+    ##### 2.1 Firstly, we will summerise what we have done so far,
+
+    - Samples of houses with factors as pair, i.e. (Number of bedrooms, living area) 
+    - Corresponding samples of sold-price
+    - A pair of **NAIVE** weights correspond to the two factors
+    - A list of predicted price based on factors and our **NAIVE** weights
+    - A function that compute the **:red[LOSS]** (differences between the real sold-prices and predicted prices), then average out the list of samples.
+    - A way of decrease loss by updating weights: go to the negtive direction of the gradient of the loss function
+
+    We hope to learn something from the **:red[LOSS]** and thus update our weights to be a smarter pair which give us better prediction closing to the real price.  
+
+    Let's describe the **:red[LOSS]** function with slightly more details. We will represent our predictions as $f(\Bbb{x}, \Bbb{w}) := \hat{y}$, called "y-hat", then the loss function can be represented as
+    """)
+    st.latex(r'''L(f(\Bbb{x_i}, \Bbb{w}),\Bbb{y})= L(\hat{y},y) :=\frac{\sum_{i=1}^{l}(\hat{y}_i-y)^2}{l}''')
+    st.markdown("""
+    As there is only one variable in the expression, we can replace $\hat{y}_i - y$ as $t_i$, so we have""")
+    st.latex(r'''L(t) := \frac{\sum_{i=1}^{l}t_i^2}{l}''')
+    st.markdown("""
+    It is more familiar to us. Looks like $f(t) = at^2$ for $a$ to be a positive constant, right?
+
+    We discussed that this loss function is **Convex**
+    """)
+
+    st.write("##")
+
+    st.markdown("""
+
+    ##### 2.2 Can we reach the minimum?
+
+    However, even we know there is a minumum, and we know a way to approach the minimum, **It is not garanteed that we can eventually reach there with finite steps**, let's see a classic counterexample:
+    """)
+    st.image("https://i.ibb.co/pfJB1Q5/Quodratic4.png", width=300,)
+    st.markdown("""
+    From above, the funciton $f(x):= |x|$ is convex. If we use the method we discussed, after certain steps, the loss will stuck at a certain level without decreasing any more. So based on method of gradient descent, we need another feature from our **:red[Loss]** function, differenciability and smoothness (**NOTE**: in practice, there are ways to deal with non-differenciable loss functions such as subgradient, which is beyone the discussion here). 
+
+    Luckily, our choice of “Averaging the squaring of the errors” satisfy both requirement! It is differenciable, and it is smooth, more presicely, **Lipschitz smooth**, or **L-smooth**. Definition of L-smooth can be expressed as: 
+        
+        - A continuously differentiable function is L-smooth if its gradient satisfy: 
+""")
+    st.latex(r'''\|\nabla f(x) - \nabla f(y)\| \le L\|y - x\|''')
+
+    st.markdown("Please be aware that L-continuous and L-smooth are different concepts! Later on, you might come across some Machine learning terminology that require the function to be L-continuous, or specifically 1-L continuous, we might discuss it more later on.")
+
+    st.markdown("""
+The L-smooth means the change of the gradient, would never like the absolute function above, change rapidly. It garantee that the gradient of function changes smoothly (as it has both upper bound and lower bound now). More importantly, it garanteed that, if we choose a correct learning rate, we will decrease our loss!
+
+We are so lucky to choose a function that fit all requirement here! Well, accidently the funciton we choosed was a famous and classic one called **Mean Squared Error (MSE)**.
+
+Now let's look at detail how to compute the gradient of our loss function. If you are not familiar with calculus, you can just accept the result for now.
+""")
+    st.latex(r'''L(w) = \frac{1}{l} \sum_{i=1}^{l}(y_i-x_iw)^2''')
+    st.latex(r'''\frac{\partial L}{\partial w} = \frac{2}{l}\sum_{i=1}^{l}x_i(y_i - x_iw) = \frac{2}{l}\sum_{i=1}^{l}x_ie_i''')
+
+    st.markdown("""
+where $e_i$ is the difference between predicted value and real price in ith row. From the equation above, one can check that, the gradient of MSE is larger when the error is larger, smaller when error is smaller.
+""")
+
+    st.write("##")
+
+    st.markdown("""
+
+    ##### 2.3 Let's actually do the calculation,
+
+**Step 0**:
+
+| # Bedrooms | Living area | Sold Price | Myprediction | Error    |
+| ---------- | ----------- | ---------- | ------------ | --- |
+| 4          | 170         | 1,200,000  | 37000        |-1,163,000 |
+| 3          | 130         | 980,000    | 28000        |-952,000   |
+| 5          | 230         | 1,600,000  | 48000        |-1,552,000 |
+
+- $w_0 = (5000, 100)$
+- learning rate a = 0.00001$
+- Calculate""") 
+    st.latex(r'''w_1 = w_0 - \alpha \frac{2}{3}\sum_{i=1}^{3}x_ie_i = w_0 -(-101.8, -4522.9) = (5000 + 101.8, 100 + 4522.9) = (5101.8, 4622.9)''')
+
+    st.markdown("""
+**Step 1**: Calculate new predictions and errors using updated weights, $w_1$
+
+| # Bedrooms | Living area | Sold Price |Myprediction| Error|
+| ---------- | ----------- | ---------- | ------------ | --- |
+| 4 | 170 | 1,200,000 | 806300.2|-393699.8|
+| 3 | 130 | 980,000   | 616282.4|-363717.6 |
+| 5 | 230 | 1,600,000 | 1088776|-511224|
+
+- $w_1 = (5101.8, 4622.9)$
+- learning rate a = 0.00001
+- Calculate new weights by:
+""")
+    st.latex(r'''w_2 = w_1 - \alpha \frac{2}{3}\sum_{i=1}^{3}x_ie_i= w_1 -(-34.8, -1545.3) = (5101.8 + 34.8, 4622.9 + 1545.3) = (5136.6, 6168.2)''')
+
+    st.markdown("""
+    **Step 2**: Calculate new predictions and errors using updated weights, $w_2$, (5136.6, 6168.2)
+
+| # Bedrooms | Living area | Sold Price |Myprediction| Error|
+| ---------- | ----------- | ---------- | ------------ | --- |
+| 4 | 170 | 1,200,000 | 1,069,140.4|-130,859.6|
+| 3 | 130 | 980,000   | 817,275.8|-162,724.2 |
+| 5 | 230 | 1,600,000 | 1,444,369|-155,631|
+
+As you can see from the example above, after 2 iterations, our naive model become much closer to the real price. You might also expect that after more rounds, the error would be smaller. Some reader might also realise the in our example here, the optimal weights can be found explicitly by **:blue[linear regression]**. We are not going to details of linear regression in this article. The real power of Gradient Descent Algorithm is we can build up more conplicated model and train them now.
+
+""")
+
+    st.write("##")
+
+    st.markdown("""
+In the real life, please don't be panic to do the calculation above! Computer will do the job for you. I am writing them here just for demonstration, and I would not garantee my accuracy of each number, I trust computer much more than my calculation skills.
+
+From the next chapter, we will moving on to see how we can use the thing we have leant to deal with some real Natural Language Processing problems. We will use a new example from a classic application of NLP, Sentiment Analysis.
+""")
+
+    with st.expander("Pass the quiz to get to the next section :)"):
+        st.markdown("To access to the next section, you have to finish the little test below: :smile:")
+        st.write("##")
+        st.markdown("Q1. Is the function $ f(x) := 3x^2 $ L-smooth? ")
+
+        q1 = st.radio("", ["A. yes", "B. no"])
+
+        st.write("##")
+        st.markdown("Q2. With the context from the Q1, what is the mininum L for f(x) to be L-smooth? ")
+
+        q2 = st.radio("", ["A. 2", "B. 4", "C. 6", "D, 8"])
+
+        if st.button("Try your luck..."):
+            if q1 == "A. yes" and q2 == "C. 6":
+                st.write("Congratulations! The password for the next section is smoothness. ")
+            else: 
+                st.write("Oop! Unlucky... You may try again!")
+
+
+
+

requirements.txt

@@ -1 +1,2 @@
-streamlit==1.24.0
+streamlit==1.24.0
+streamlit_book==0.7.5

tmp/users.csv

@@ -0,0 +1,10 @@
+user_id,token,datetime
+0,abc123,2023-07-15 12:35:29
+1,tte831,2023-07-15 12:35:29
+2,dcg447,2023-07-15 12:37:20
+3,kbb530,2023-07-15 12:53:27
+4,kdt233,2023-07-15 13:34:12
+5,epo188,2023-07-15 22:25:58
+6,xhz259,2023-07-16 10:46:21
+7,cxz229,2023-07-17 13:22:47
+8,xny887,2023-07-17 14:07:05

utils.py

@@ -1,26 +1,26 @@
 import streamlit as st
 
-def check_password():
+def check_password(key):
     """Returns `True` if the user had the correct password."""
 
     def password_entered():
         """Checks whether a password entered by the user is correct."""
-        if st.session_state["password"] == st.secrets["password"]:
+        if st.session_state[key] == st.secrets[key]:
             st.session_state["password_correct"] = True
-            del st.session_state["password"]  # don't store password
+            del st.session_state[key]  # don't store password
         else:
             st.session_state["password_correct"] = False
 
     if "password_correct" not in st.session_state:
         # First run, show input for password.
         st.text_input(
-            "Password", type="password", on_change=password_entered, key="password"
+            "Password", type="password", on_change=password_entered, key=key
         )
         return False
     elif not st.session_state["password_correct"]:
         # Password not correct, show input + error.
         st.text_input(
-            "Password", type="password", on_change=password_entered, key="password"
+            "Password", type="password", on_change=password_entered, key=key
         )
         st.error("😕 Password incorrect")
         return False