Update app.py

app.py

@@ -563,7 +563,775 @@ st.plotly_chart(fig_bar)
 # # In[ ]:
 #
 
-# qatar.to_csv("/content/drive/MyDrive/data/last_team_scores.csv", index = False)
+final_df = pd.read_csv('./data/training.csv')
+final_df.tail()
+
+
+# # GROUP STAGE MODELING
+
+# ### Choosing a model
+
+# In[4]:
+
+
+# I save the original data frame in a flag to then train the final pipeline
+pipe_DF = final_df
+# Dummies for categorical columns
+final_df = pd.get_dummies(final_df)
+
+
+# I split the dataset into training, testing and validation.
+
+# In[5]:
+
+
+X = final_df.drop('Team1_Result',axis=1)
+y = final_df['Team1_Result']
+from sklearn.model_selection import train_test_split
+X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.1, random_state=42)
+X_hold_test, X_test, y_hold_test, y_test = train_test_split(X_val, y_val, test_size=0.5, random_state=42)
+
+
+#  Scaling
+
+# In[6]:
+
+
+from sklearn.preprocessing import StandardScaler
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+X_hold_test = scaler.transform(X_hold_test)
+
+
+# Defining function to display the confusion matrix quickly.
+
+# In[7]:
+
+
+from sklearn.metrics import classification_report,ConfusionMatrixDisplay
+def metrics_display(model):
+    model.fit(X_train,y_train)
+    y_pred = model.predict(X_test)
+    print(classification_report(y_test,y_pred))
+    ConfusionMatrixDisplay.from_predictions(y_test,y_pred);
+
+
+# * **Random Forest**
+
+# In[8]:
+
+
+from sklearn.ensemble import RandomForestClassifier
+metrics_display(RandomForestClassifier())
+
+
+# * **Ada Boost Classifier**
+
+# In[9]:
+
+
+from sklearn.ensemble import AdaBoostClassifier
+metrics_display(AdaBoostClassifier())
+
+
+# * **XGB Boost**
+
+# In[10]:
+
+
+from xgboost import XGBClassifier
+metrics_display(XGBClassifier(use_label_encoder=False))
+
+
+# * **Neural network**
+# 
+# 
+
+# In[11]:
+
+
+import keras
+from keras import Sequential
+from keras.layers import Dense,Dropout
+from keras import Input
+
+X_train.shape
+
+
+# In[12]:
+
+
+model = Sequential()
+model.add(Input(shape=(404,)))
+model.add(Dense(300,activation='relu'))
+model.add(Dropout(0.3))
+model.add(Dense(200,activation='relu'))
+model.add(Dropout(0.3))
+model.add(Dense(100,activation='relu'))
+model.add(Dropout(0.3))
+model.add(Dense(3,activation='softmax'))
+model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X_train,y_train,epochs=10,validation_split=0.2)
+
+y_pred1 = model.predict(X_test)
+y_pred1 = np.argmax(y_pred1,axis=1)
+print(classification_report(y_test,y_pred1))
+ConfusionMatrixDisplay.from_predictions(y_test,y_pred1)
+
+
+# The XGBoost model performs better than the others, so I will tune its hyperparameters and evaluate the performance based on the validation dataset.
+
+# ### XGB Boost - Tuning & Hold-out Validation
+
+# In[13]:
+
+
+from sklearn.model_selection import GridSearchCV
+from sklearn.metrics import accuracy_score
+
+# Make a dictionary of hyperparameter values to search
+search_space = {
+    "n_estimators" : [200,250,300,350,400,450,500],
+    "max_depth" : [3,4,5,6,7,8,9],
+    "gamma" : [0.001,0.01,0.1],
+    "learning_rate" : [0.001,0.01,0.1]
+}
+
+
+# In[14]:
+
+
+# make a GridSearchCV object
+GS = GridSearchCV(estimator = XGBClassifier(use_label_encoder=False),
+                  param_grid = search_space,
+                  scoring = 'accuracy',
+                  cv = 5,
+                  verbose = 4)
+
+
+# Uncomment the following line to enable the tuning. The best result I found was: gamma = 0.01, learning_rate = 0.01, n_estimators = 300, max_depth = 4
+
+# In[15]:
+
+
+#GS.fit(X_train,y_train)
+
+
+# To get only the best hyperparameter values
+
+# In[16]:
+
+
+#print(GS.best_params_) 
+
+
+# Initially, I validate the model with its default parameters, and then I will validate it with its tuned parameters.
+
+# * **Default Hyperparameters**
+
+# In[17]:
+
+
+model = XGBClassifier()
+model.fit(X_train,y_train)
+y_pred = model.predict(X_hold_test)
+print(classification_report(y_hold_test,y_pred))
+ConfusionMatrixDisplay.from_predictions(y_hold_test,y_pred);
+
+
+# * **Tuned Hyperparameters**
+
+# In[18]:
+
+
+model = XGBClassifier(use_label_encoder = False, gamma = 0.01, learning_rate = 0.01, n_estimators = 300, max_depth = 4)
+model.fit(X_train,y_train)
+y_pred = model.predict(X_hold_test)
+print(classification_report(y_hold_test,y_pred))
+ConfusionMatrixDisplay.from_predictions(y_hold_test,y_pred);
+
+
+# The model improves a bit, so I will create a pipe to use the model later easily.
+
+# ### Creating a pipeline for the XGB model
+
+# In[19]:
+
+
+from sklearn.preprocessing import OneHotEncoder
+from sklearn.compose import make_column_transformer
+column_trans = make_column_transformer(
+    (OneHotEncoder(),['Team1', 'Team2']),remainder='passthrough')
+
+pipe_X = pipe_DF.drop('Team1_Result',axis=1)
+pipe_y = pipe_DF['Team1_Result']
+
+from sklearn.pipeline import make_pipeline
+pipe_League = make_pipeline(column_trans,StandardScaler(with_mean=False),XGBClassifier(use_label_encoder=False, gamma= 0.01, learning_rate= 0.01, n_estimators= 300, max_depth= 4))
+pipe_League.fit(pipe_X,pipe_y)
+
+
+# In[20]:
+
+
+import joblib
+joblib.dump(pipe_League,"./groups_stage_prediction.pkl")
+
+
+# # KNOCKOUT STAGE MODELING
+
+# ### Choosing the model 
+# 
+# Removing Draw status.
+
+# In[21]:
+
+
+knock_df = pipe_DF[pipe_DF['Team1_Result'] != 2]
+
+
+# In[22]:
+
+
+pipe_knock_df = knock_df
+knock_df = pd.get_dummies(knock_df)
+X = knock_df.drop('Team1_Result',axis=1)
+y = knock_df['Team1_Result']
+
+X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
+X_hold_test, X_test, y_hold_test, y_test = train_test_split(X_val, y_val, test_size=0.5, random_state=42)
+
+
+# * **Ada Boost Classifier**
+
+# In[23]:
+
+
+metrics_display(AdaBoostClassifier())
+
+
+# *   **Random Forest**
+# 
+# 
+# 
+
+# In[26]:
+
+
+metrics_display(RandomForestClassifier())
+
+
+# * **XGB Boost**
+
+# In[27]:
+
+
+metrics_display(XGBClassifier(use_label_encoder=False))
+
+
+# * **Neural network**
+
+# In[28]:
+
+
+X_train.shape
+
+
+# In[30]:
+
+
+model = Sequential()
+model.add(Input(shape=(399,)))
+model.add(Dense(300,activation='relu'))
+model.add(Dropout(0.3))
+model.add(Dense(200,activation='relu'))
+model.add(Dropout(0.3))
+model.add(Dense(100,activation='relu'))
+model.add(Dropout(0.3))
+model.add(Dense(2,activation='softmax'))
+model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X_train,y_train,epochs=10,validation_split=0.2)
+
+y_pred1 = model.predict(X_test)
+y_pred1 = np.argmax(y_pred1,axis=1)
+print(classification_report(y_test,y_pred1))
+ConfusionMatrixDisplay.from_predictions(y_test,y_pred1)
+
+
+# All models have very similar performance. Therefore I will tune the Random Forest model and the XGB Boost.
+
+# ### Random Forest - Tuning & Hold-out Validation 
+
+# In[31]:
+
+
+search_space = {
+    "max_depth" : [11,12,13,14,15,16],
+    "max_leaf_nodes" : [170,180,190,200,210,220,230],
+    "min_samples_leaf" : [3,4,5,6,7,8],
+    "n_estimators" : [310,320,330,340,350]
+}
+
+
+# In[32]:
+
+
+GS = GridSearchCV(estimator = RandomForestClassifier(),
+                  param_grid = search_space,
+                  scoring = 'accuracy',
+                  cv = 5,
+                  verbose = 4)
+
+
+# Uncomment the following lines to enable the tuning. The best result I found was: max_depth = 16, n_estimators = 320, max_leaf_nodes = 190, min_samples_leaf = 5
+
+# In[33]:
+
+
+#GS.fit(X_train,y_train)
+
+
+# In[34]:
+
+
+#print(GS.best_params_)
+
+
+# * **Default Hyperparameters**
+
+# In[35]:
+
+
+model = RandomForestClassifier()
+model.fit(X_train,y_train)
+y_pred = model.predict(X_hold_test)
+print(classification_report(y_hold_test,y_pred))
+ConfusionMatrixDisplay.from_predictions(y_hold_test,y_pred);
+
+
+# * **Tuned Hyperparameters**
+
+# In[36]:
+
+
+model = RandomForestClassifier(max_depth= 16, n_estimators=320, max_leaf_nodes= 190, min_samples_leaf= 5)
+model.fit(X_train,y_train)
+y_pred = model.predict(X_hold_test)
+print(classification_report(y_hold_test,y_pred))
+ConfusionMatrixDisplay.from_predictions(y_hold_test,y_pred);
+
+
+# The Random Forest greatly improves performance with the tuned hyperparameters; let's see the XGB Boost model.
+
+# ### XGB Boost - Tuning & Hold-out Validation
+
+# In[37]:
+
+
+search_space = {
+    "n_estimators" : [300,350,400,450,500,550,600],
+    "max_depth" : [3,4,5,6,7,8,9],
+    "gamma" : [0.001,0.01,0.1],
+    "learning_rate" : [0.001,0.01]
+}
+
+
+# In[38]:
+
+
+GS = GridSearchCV(estimator = XGBClassifier(use_label_encoder=False),
+                  param_grid = search_space,
+                  scoring = 'accuracy',
+                  cv = 5,
+                  verbose = 4)
+
+
+# In[39]:
+
+
+#GS.fit(X_train,y_train)
+
+
+# In[40]:
+
+
+#print(GS.best_params_) # to get only the best hyperparameter values that we searched for
+
+
+# Uncomment the following lines to enable the tuning. The best result I found was: gamma = 0.01, learning_rate = 0.01, max_depth = 5, n_estimators = 500
+
+# * **Default Hyperparameters**
+
+# In[41]:
+
+
+model = XGBClassifier()
+model.fit(X_train,y_train)
+y_pred = model.predict(X_hold_test)
+print(classification_report(y_hold_test,y_pred))
+ConfusionMatrixDisplay.from_predictions(y_hold_test,y_pred);
+
+
+# * **Tuned Hyperparameters**
+
+# In[42]:
+
+
+model = XGBClassifier(gamma=0.01,learning_rate=0.01, max_depth=5, n_estimators=500)
+model.fit(X_train,y_train)
+y_pred = model.predict(X_hold_test)
+print(classification_report(y_hold_test,y_pred))
+ConfusionMatrixDisplay.from_predictions(y_hold_test,y_pred);
+
+
+# The model does not improve notably. However, it does improve compared to the Random Forest.
+
+# ### Creating a pipeline for the XGB Boost model
+
+# In[43]:
+
+
+pipe_X = pipe_knock_df.drop('Team1_Result',axis=1)
+pipe_y = pipe_knock_df['Team1_Result']
+pipe_knock = make_pipeline(column_trans,StandardScaler(with_mean=False),XGBClassifier(gamma=0.01,learning_rate=0.01, max_depth=5, n_estimators=500))
+pipe_knock.fit(pipe_X,pipe_y)
+
+
+# In[44]:
+
+
+joblib.dump(pipe_knock,"./knockout_stage_prediction.pkl")
+
+    st.title("FIFA winner predication")
+    st.write('This app predict 2022 FIFA winner')
+
+    if st.button("Predict FIFA Winner"):
+
+        last_team_scores = pd.read_csv('./data/last_team_scores.csv')
+        last_team_scores.tail()
+
+        squad_stats = pd.read_csv('./data/squad_stats.csv')
+        squad_stats.tail()
+
+        group_matches = pd.read_csv('./data/Qatar_group_stage.csv')
+        round_16 = group_matches.iloc[48:56, :]
+        quarter_finals = group_matches.iloc[56:60, :]
+        semi_finals = group_matches.iloc[60:62, :]
+        final = group_matches.iloc[62:63, :]
+        second_final = group_matches.iloc[63:64, :]
+        group_matches = group_matches.iloc[:48, :]
+        group_matches.tail()
+
+        xgb_gs_model = joblib.load("./groups_stage_prediction.pkl")
+
+        xgb_ks_model = joblib.load("./knockout_stage_prediction.pkl")
+
+        team_group = group_matches.drop(['country2'], axis=1)
+        team_group = team_group.drop_duplicates().reset_index(drop=True)
+        team_group = team_group.rename(columns={"country1": "team"})
+        team_group.head(5)
+
+        def matches(g_matches):
+            g_matches.insert(2, 'potential1',
+                             g_matches['country1'].map(squad_stats.set_index('nationality_name')['potential']))
+            g_matches.insert(3, 'potential2',
+                             g_matches['country2'].map(squad_stats.set_index('nationality_name')['potential']))
+            g_matches.insert(4, 'rank1', g_matches['country1'].map(last_team_scores.set_index('team')['rank']))
+            g_matches.insert(5, 'rank2', g_matches['country2'].map(last_team_scores.set_index('team')['rank']))
+            pred_set = []
+
+            for index, row in g_matches.iterrows():
+                if row['potential1'] > row['potential2'] and abs(row['potential1'] - row['potential2']) > 2:
+                    pred_set.append({'Team1': row['country1'], 'Team2': row['country2']})
+                elif row['potential2'] > row['potential1'] and abs(row['potential2'] - row['potential1']) > 2:
+                    pred_set.append({'Team1': row['country2'], 'Team2': row['country1']})
+                else:
+                    if row['rank1'] > row['rank2']:
+                        pred_set.append({'Team1': row['country1'], 'Team2': row['country2']})
+                    else:
+                        pred_set.append({'Team1': row['country2'], 'Team2': row['country1']})
+
+            pred_set = pd.DataFrame(pred_set)
+            pred_set.insert(2, 'Team1_FIFA_RANK', pred_set['Team1'].map(last_team_scores.set_index('team')['rank']))
+            pred_set.insert(3, 'Team2_FIFA_RANK', pred_set['Team2'].map(last_team_scores.set_index('team')['rank']))
+            pred_set.insert(4, 'Team1_Goalkeeper_Score',
+                            pred_set['Team1'].map(last_team_scores.set_index('team')['goalkeeper_score']))
+            pred_set.insert(5, 'Team2_Goalkeeper_Score',
+                            pred_set['Team2'].map(last_team_scores.set_index('team')['goalkeeper_score']))
+            pred_set.insert(6, 'Team1_Defense', pred_set['Team1'].map(last_team_scores.set_index('team')['defense_score']))
+            pred_set.insert(7, 'Team1_Offense', pred_set['Team1'].map(last_team_scores.set_index('team')['offense_score']))
+            pred_set.insert(8, 'Team1_Midfield',
+                            pred_set['Team1'].map(last_team_scores.set_index('team')['midfield_score']))
+            pred_set.insert(9, 'Team2_Defense', pred_set['Team2'].map(last_team_scores.set_index('team')['defense_score']))
+            pred_set.insert(10, 'Team2_Offense', pred_set['Team2'].map(last_team_scores.set_index('team')['offense_score']))
+            pred_set.insert(11, 'Team2_Midfield',
+                            pred_set['Team2'].map(last_team_scores.set_index('team')['midfield_score']))
+            return pred_set
+
+        def print_results(dataset, y_pred, matches, proba):
+            results = []
+            for i in range(dataset.shape[0]):
+                print()
+                if y_pred[i] == 2:
+                    print(matches.iloc[i, 0] + " vs. " + matches.iloc[i, 1] + " => Draw")
+                    results.append({'result': 'Draw'})
+                elif y_pred[i] == 1:
+                    print(matches.iloc[i, 0] + " vs. " + matches.iloc[i, 1] + " => Winner: " + dataset.iloc[i, 0])
+                    results.append({'result': dataset.iloc[i, 0]})
+                else:
+                    print(matches.iloc[i, 0] + " vs. " + matches.iloc[i, 1] + " => Winner: " + dataset.iloc[i, 1])
+                    results.append({'result': dataset.iloc[i, 1]})
+                try:
+                    print('Probability of ' + dataset.iloc[i, 0] + ' winning: ', '%.3f' % (proba[i][1]))
+                    print('Probability of Draw: ', '%.3f' % (proba[i][2]))
+                    print('Probability of ' + dataset.iloc[i, 1] + ' winning: ', '%.3f' % (proba[i][0]))
+                except:
+                    print('Probability of ' + dataset.iloc[i, 1] + ' winning: ', '%.3f' % (proba[i][0]))
+                print("")
+            results = pd.DataFrame(results)
+            matches = pd.concat([matches.group, results], axis=1)
+            return matches
+
+        def winner_to_match(round, prev_match):
+            round.insert(0, 'c1', round['country1'].map(prev_match.set_index('group')['result']))
+            round.insert(1, 'c2', round['country2'].map(prev_match.set_index('group')['result']))
+            round = round.drop(['country1', 'country2'], axis=1)
+            round = round.rename(columns={'c1': 'country1', 'c2': 'country2'}).reset_index(drop=True)
+            return round
+
+        def prediction_knockout(round):
+            dataset_round = matches(round)
+            prediction_round = xgb_ks_model.predict(dataset_round)
+            proba_round = xgb_ks_model.predict_proba(dataset_round)
+
+            # prediction_round = ada_ks_model.predict(dataset_round)
+            # proba_round = ada_ks_model.predict_proba(dataset_round)
+
+            # prediction_round = rf_ks_model.predict(dataset_round)
+            # proba_round = rf_ks_model.predict_proba(dataset_round)
+
+            results_round = print_results(dataset_round, prediction_round, round, proba_round)
+            return results_round
+
+        def center_str(round):
+            spaces = ['', ' ', '  ', '   ', '    ', '     ', ]
+            for j in range(2):
+                for i in range(round.shape[0]):
+                    if (13 - len(round.iloc[i, j])) % 2 == 0:
+                        round.iloc[i, j] = spaces[int((13 - len(round.iloc[i, j])) / 2)] + round.iloc[i, j] + spaces[
+                            int((13 - len(round.iloc[i, j])) / 2)]
+                    else:
+                        round.iloc[i, j] = spaces[int(((13 - len(round.iloc[i, j])) / 2) - 0.5)] + round.iloc[i, j] + \
+                                           spaces[int(((13 - len(round.iloc[i, j])) / 2) + 0.5)]
+            return round
+
+        def center2(a):
+            spaces = ['', ' ', '  ', '   ', '    ', '     ', '      ', '       ', '        ', '         ', '          ',
+                      '           ', '            ', '             ', '              ', '               ',
+                      '                ', '                 ', '                  ', '                   ',
+                      '                    ']
+            if (29 - len(a)) % 2 == 0:
+                a = spaces[int((29 - len(a)) / 2)] + a + spaces[int((29 - len(a)) / 2)]
+            else:
+                a = spaces[int(((29 - len(a)) / 2) - 0.5)] + a + spaces[int(((29 - len(a)) / 2) + 0.5)]
+            return a
+
+        dataset_groups = matches(group_matches)
+        dataset_groups.tail()
+        print(dataset_groups)
+
+        prediction_groups = xgb_gs_model.predict(dataset_groups)
+        proba = xgb_gs_model.predict_proba(dataset_groups)
+
+        # prediction_groups = ada_gs_model.predict(dataset_groups)
+        # proba = ada_gs_model.predict_proba(dataset_groups)
+
+        # prediction_groups = rf_gs_model.predict(dataset_groups)
+        # proba = rf_gs_model.predict_proba(dataset_groups)
+
+        results = print_results(dataset_groups, prediction_groups, group_matches, proba)
+
+        team_group['points'] = 0
+        team_group
+        for i in range(results.shape[0]):
+            for j in range(team_group.shape[0]):
+                if results.iloc[i, 1] == team_group.iloc[j, 0]:
+                    team_group.iloc[j, 2] += 3
+
+        print(team_group.groupby(['group', 'team']).mean().astype(int))
+
+        round_of_16 = team_group[team_group['points'] > 5].reset_index(drop=True)
+        round_of_16['group'] = (4 - 1 / 3 * round_of_16.points).astype(int).astype(str) + round_of_16.group
+        round_of_16 = round_of_16.rename(columns={"team": "result"})
+
+        round_16 = winner_to_match(round_16, round_of_16)
+        results_round_16 = prediction_knockout(round_16)
+
+        quarter_finals = winner_to_match(quarter_finals, results_round_16)
+        results_quarter_finals = prediction_knockout(quarter_finals)
+
+        semi_finals = winner_to_match(semi_finals, results_quarter_finals)
+        results_finals = prediction_knockout(semi_finals)
+
+        final = winner_to_match(final, results_finals)
+        winner = prediction_knockout(final)
+
+        second = results_finals[~results_finals.result.isin(winner.result)]
+        results_finals_3 = results_quarter_finals[~results_quarter_finals.result.isin(results_finals.result)]
+        results_finals_3.iloc[0, 0] = 'z1'
+        results_finals_3.iloc[1, 0] = 'z2'
+        second_final = winner_to_match(second_final, results_finals_3)
+        third = prediction_knockout(second_final)
+
+        round_16 = center_str(round_16)
+        quarter_finals = center_str(quarter_finals)
+        semi_finals = center_str(semi_finals)
+        final = center_str(final)
+        group_matches = center_str(group_matches)
+
+        # Function to center align text
+        def center(text):
+            return f"<div style='text-align: center;'>{text}</div>"
+
+        # Function to generate the formatted text
+        def generate_text(round_16, quarter_finals, semi_finals, final):
+            formatted_text = (
+                    round_16.iloc[
+                        0, 0] + '━━━━┓                                                                                                                             ┏━━━━' +
+                    round_16.iloc[4, 0] + '\n' +
+                    '                 ┃                                                                                                                             ┃\n' +
+                    '                 ┃━━━━' + quarter_finals.iloc[
+                        0, 0] + '━━━━┓                                                                                 ┏━━━━' +
+                    quarter_finals.iloc[2, 0] + '━━━━┃\n' +
+                    '                 ┃                     ┃                                                                                 ┃                     ┃\n' +
+                    round_16.iloc[
+                        0, 1] + '━━━━┛                     ┃                                                                                 ┃                     ┗━━━━' +
+                    round_16.iloc[4, 1] + '\n' +
+                    '                                       ┃━━━━' + semi_finals.iloc[
+                        0, 0] + '━━━━┓                                     ┏━━━━' + semi_finals.iloc[1, 0] + '━━━━┃\n' +
+                    round_16.iloc[
+                        1, 0] + '━━━━┓                     ┃                     ┃                                     ┃                     ┃                     ┏━━━━' +
+                    round_16.iloc[5, 0] + '\n' +
+                    '                 ┃                     ┃                     ┃                                     ┃                     ┃                     ┃\n' +
+                    '                 ┃━━━━' + quarter_finals.iloc[
+                        0, 1] + '━━━━┛                     ┃                                     ┃                     ┗━━━━' +
+                    quarter_finals.iloc[2, 1] + '━━━━┃\n' +
+                    '                 ┃                                           ┃                                     ┃                                           ┃\n' +
+                    round_16.iloc[
+                        1, 1] + '━━━━┛                                           ┃                                     ┃                                           ┗━━━━' +
+                    round_16.iloc[5, 1] + '\n' +
+                    '                                                             ┃━━━━' + final.iloc[0, 0] + 'vs.' +
+                    final.iloc[0, 1] + '━━━━┃\n' +
+                    round_16.iloc[
+                        2, 0] + '━━━━┓                                           ┃                                     ┃                                           ┏━━━━' +
+                    round_16.iloc[6, 0] + '\n' +
+                    '                 ┃                                           ┃                                     ┃                                           ┃\n' +
+                    '                 ┃━━━━' + quarter_finals.iloc[
+                        1, 0] + '━━━━┓                     ┃                                     ┃                     ┏━━━━' +
+                    quarter_finals.iloc[3, 0] + '━━━━┃\n' +
+                    '                 ┃                     ┃                     ┃                                     ┃                     ┃                     ┃\n' +
+                    round_16.iloc[
+                        2, 1] + '━━━━┛                     ┃                     ┃                                     ┃                     ┃                     ┗━━━━' +
+                    round_16.iloc[6, 1] + '\n' +
+                    '                                       ┃━━━━' + semi_finals.iloc[
+                        0, 1] + '━━━━┛                                     ┗━━━━' + semi_finals.iloc[1, 1] + '━━━━┃\n' +
+                    round_16.iloc[
+                        3, 0] + '━━━━┓                     ┃                                                                                 ┃                     ┏━━━━' +
+                    round_16.iloc[7, 0] + '\n' +
+                    '                 ┃                     ┃                                                                                 ┃                     ┃\n' +
+                    '                 ┃━━━━' + quarter_finals.iloc[
+                        1, 1] + '━━━━┛                                                                                 ┗━━━━' +
+                    quarter_finals.iloc[3, 1] + '━━━━┃\n' +
+                    '                 ┃                                                                                                                             ┃\n' +
+                    round_16.iloc[
+                        3, 1] + '━━━━┛                                                                                                                             ┗━━━━' +
+                    round_16.iloc[7, 1] + '\n' +
+                    "                                                                 " + center(
+                "\U0001F947" + winner.iloc[0, 1]) + '\n' +
+                    "                                                                 " + center(
+                "\U0001F948" + second.iloc[0, 1]) + '\n' +
+                    "                                                                 " + center(
+                "\U0001F949" + third.iloc[0, 1])
+            )
+            return formatted_text
+
+        # Generate the formatted text
+        formatted_text = generate_text(round_16, quarter_finals, semi_finals, final)
+
+        # Define the round_16, quarter_finals, semi_finals, final DataFrames
+        # Replace the DataFrame creation with your actual data
+
+        # Display the formatted text
+        st.text(formatted_text)
+        # st.markdown(formatted_text)
+
+        print(round_16.iloc[
+                  0, 0] + '━━━━┓                                                                                                                             ┏━━━━' +
+              round_16.iloc[4, 0])
+        print(
+            '                 ┃                                                                                                                             ┃')
+        print('                 ┃━━━━' + quarter_finals.iloc[
+            0, 0] + '━━━━┓                                                                                 ┏━━━━' +
+              quarter_finals.iloc[2, 0] + '━━━━┃')
+        print(
+            '                 ┃                     ┃                                                                                 ┃                     ┃')
+        print(round_16.iloc[
+                  0, 1] + '━━━━┛                     ┃                                                                                 ┃                     ┗━━━━' +
+              round_16.iloc[4, 1])
+        print('                                       ┃━━━━' + semi_finals.iloc[
+            0, 0] + '━━━━┓                                     ┏━━━━' + semi_finals.iloc[1, 0] + '━━━━┃')
+        print(round_16.iloc[
+                  1, 0] + '━━━━┓                     ┃                     ┃                                     ┃                     ┃                     ┏━━━━' +
+              round_16.iloc[5, 0])
+        print(
+            '                 ┃                     ┃                     ┃                                     ┃                     ┃                     ┃')
+        print('                 ┃━━━━' + quarter_finals.iloc[
+            0, 1] + '━━━━┛                     ┃                                     ┃                     ┗━━━━' +
+              quarter_finals.iloc[2, 1] + '━━━━┃')
+        print(
+            '                 ┃                                           ┃                                     ┃                                           ┃')
+        print(round_16.iloc[
+                  1, 1] + '━━━━┛                                           ┃                                     ┃                                           ┗━━━━' +
+              round_16.iloc[5, 1])
+        print('                                                             ┃━━━━' + final.iloc[0, 0] + 'vs.' + final.iloc[
+            0, 1] + '━━━━┃')
+        print(round_16.iloc[
+                  2, 0] + '━━━━┓                                           ┃                                     ┃                                           ┏━━━━' +
+              round_16.iloc[6, 0])
+        print(
+            '                 ┃                                           ┃                                     ┃                                           ┃')
+        print('                 ┃━━━━' + quarter_finals.iloc[
+            1, 0] + '━━━━┓                     ┃                                     ┃                     ┏━━━━' +
+              quarter_finals.iloc[3, 0] + '━━━━┃')
+        print(
+            '                 ┃                     ┃                     ┃                                     ┃                     ┃                     ┃')
+        print(round_16.iloc[
+                  2, 1] + '━━━━┛                     ┃                     ┃                                     ┃                     ┃                     ┗━━━━' +
+              round_16.iloc[6, 1])
+        print('                                       ┃━━━━' + semi_finals.iloc[
+            0, 1] + '━━━━┛                                     ┗━━━━' + semi_finals.iloc[1, 1] + '━━━━┃')
+        print(round_16.iloc[
+                  3, 0] + '━━━━┓                     ┃                                                                                 ┃                     ┏━━━━' +
+              round_16.iloc[7, 0])
+        print(
+            '                 ┃                     ┃                                                                                 ┃                     ┃')
+        print('                 ┃━━━━' + quarter_finals.iloc[
+            1, 1] + '━━━━┛                                                                                 ┗━━━━' +
+              quarter_finals.iloc[3, 1] + '━━━━┃')
+        print(
+            '                 ┃                                                                                                                             ┃')
+        print(round_16.iloc[
+                  3, 1] + '━━━━┛                                                                                                                             ┗━━━━' +
+              round_16.iloc[7, 1])
+        print(
+            "                                                                 " + center2("\U0001F947" + winner.iloc[0, 1]))
+        print(
+            "                                                                 " + center2("\U0001F948" + second.iloc[0, 1]))
+        print(
+            "                                                                 " + center2("\U0001F949" + third.iloc[0, 1]))
+
+
 
 if __name__ == "__main__":
     main()