Add project pages and move intro page

Home.py

@@ -0,0 +1,72 @@
+import streamlit as st
+from PIL import Image
+
+# Page title
+st.title("Chris Capobianco's ML Portfolio")
+
+st.markdown('Hello, welcome to my ML portfolio.')
+st.markdown('Please have a look at the descriptions below, and select a project from the sidebar.')
+
+st.header('Projects', divider='red')
+
+mv = Image.open("assets/movie.jpg")
+# wp = Image.open("assets/weather.png")
+sm = Image.open("assets/stock-market.png")
+mu = Image.open("assets/music.jpg")
+llm = Image.open("assets/llm.png")
+
+with st.container():
+    text_column, image_column = st.columns((3,1))
+    with text_column:
+        st.subheader("Movie Recommendation", divider="green")
+        st.markdown("""
+            - Created a content based recommendation system using cosine similarity
+            - Trained on almost 5k movies and credits from the TMDB dataset available at Kaggle
+        """)
+    with image_column:
+        st.image(mv)
+
+# with st.container():
+#     text_column, image_column = st.columns((3,1))
+#     with text_column:
+#         st.subheader("Weather Classification", divider="green")
+#         st.markdown("""
+#             - Created a Random Forest classification model to predict the weather
+#             - Trained on three years of data for the city of Seattle, Washington
+#         """)
+#     with image_column:
+#         st.image(wp)
+
+with st.container():
+    text_column, image_column = st.columns((3,1))
+    with text_column:
+        st.subheader("Stock Market Forecast", divider="green")
+        st.markdown("""
+            - Created a two layer GRU model to forecast of stock prices
+            - Trained on 2006-2018 closing prices of four well known stocks
+        """)
+    with image_column:
+        st.image(sm)
+
+with st.container():
+    text_column, image_column = st.columns((3,1))
+    with text_column:
+        st.subheader("Generative Music", divider="green")
+        st.markdown("""
+            - Created a LSTM model to generate music
+            - Trained on MIDI files from Final Fantasy series
+        """)
+    with image_column:
+        st.image(mu)
+
+with st.container():
+    text_column, image_column = st.columns((3,1))
+    with text_column:
+        st.subheader("Fine Tuned LLM", divider="green")
+        st.warning("**Work In Progress**")
+        st.markdown("""
+            - Fine tuned a LLM to act like math assistant
+            - The base model is Meta's Llama 3.1 (8B) Instruct
+        """)
+    with image_column:
+        st.image(llm)

app.py

@@ -1,72 +1,29 @@
 import streamlit as st
-from PIL import Image
 
 # Page title
-st.title("Chris Capobianco's ML Portfolio")
-
-st.markdown('Hello, welcome to my ML portfolio.')
-st.markdown('Please have a look at the descriptions below, and select a project from the sidebar.')
-
-st.header('Projects', divider='red')
-
-mv = Image.open("assets/movie.jpg")
-# wp = Image.open("assets/weather.png")
-sm = Image.open("assets/stock-market.png")
-mu = Image.open("assets/music.jpg")
-llm = Image.open("assets/llm.png")
-
-with st.container():
-    text_column, image_column = st.columns((3,1))
-    with text_column:
-        st.subheader("Movie Recommendation", divider="green")
-        st.markdown("""
-            - Created a content based recommendation system using cosine similarity
-            - Trained on almost 5k movies and credits from the TMDB dataset available at Kaggle
-        """)
-    with image_column:
-        st.image(mv)
-
-# with st.container():
-#     text_column, image_column = st.columns((3,1))
-#     with text_column:
-#         st.subheader("Weather Classification", divider="green")
-#         st.markdown("""
-#             - Created a Random Forest classification model to predict the weather
-#             - Trained on three years of data for the city of Seattle, Washington
-#         """)
-#     with image_column:
-#         st.image(wp)
-
-with st.container():
-    text_column, image_column = st.columns((3,1))
-    with text_column:
-        st.subheader("Stock Market Forecast", divider="green")
-        st.markdown("""
-            - Created a two layer GRU model to forecast of stock prices
-            - Trained on 2006-2018 closing prices of four well known stocks
-        """)
-    with image_column:
-        st.image(sm)
-
-with st.container():
-    text_column, image_column = st.columns((3,1))
-    with text_column:
-        st.subheader("Generative Music", divider="green")
-        st.markdown("""
-            - Created a LSTM model to generate music
-            - Trained on MIDI files from Final Fantasy series
-        """)
-    with image_column:
-        st.image(mu)
-
-with st.container():
-    text_column, image_column = st.columns((3,1))
-    with text_column:
-        st.subheader("Fine Tuned LLM", divider="green")
-        st.warning("**Work In Progress**")
-        st.markdown("""
-            - Fine tuned a LLM to act like math assistant
-            - The base model is Meta's Llama 3.1 (8B) Instruct
-        """)
-    with image_column:
-        st.image(llm)
+st.set_page_config(page_title="Chris Capobianco's Profile", page_icon=':rocket:', layout='wide')
+
+home = st.Page('Intro.py', title = 'Home')
+
+movie_recommendation = st.Page('projects/02_Movie_Recommendation.py', title='Movie Recommendation')
+# weather_classification = st.Page('projects/04_Weather_Classification.py', title='Weather Classification')
+stock_market = st.Page('projects/05_Stock_Market.py', title='Stock Market Forecast')
+generative_music = st.Page('projects/06_Generative_Music.py', title='Generative Music')
+llm_fine_tune = st.Page('projects/07_LLM_Fine_Tuned.py', title='Fine Tuned LLM')
+
+pg = st.navigation(
+    {
+        'Home': [
+            home
+        ],
+        'Projects': [
+            movie_recommendation,
+            # weather_classification,
+            stock_market,
+            generative_music,
+            llm_fine_tune
+        ]
+    }
+)
+    
+pg.run()

projects/02_Movie_Recommendation.py

@@ -0,0 +1,59 @@
+import streamlit as st
+import pickle
+
+st.header('Movie Recommendation', divider='green')
+
+@st.cache_resource
+def load_model():
+    model_file = open('./models/movie_recommendation_model.pkl', 'rb')
+    movies_df = pickle.load(model_file)
+    cosine_sim = pickle.load(model_file)
+    indices = pickle.load(model_file)
+    model_file.close()
+    return movies_df, cosine_sim, indices
+
+# Load the Model
+movies_df, cosine_sim, indices = load_model()
+
+@st.cache_data
+def get_recommendations(title, cosine_sim = cosine_sim):
+    if title in indices:
+        idx = indices[title]
+    else:
+        print(f"Unable to find a matching movie title: {title}")
+        return []
+    similarity_scores = list(enumerate(cosine_sim[idx]))
+    similarity_scores = sorted(similarity_scores, key = lambda x: x[1], reverse = True)
+    similarity_scores = similarity_scores[1:11]
+    # (a, b) where a is id of movie, b is similarity_scores
+    movies_indices = [ind[0] for ind in similarity_scores]
+    movies = movies_df["title"].iloc[movies_indices]
+    return movies
+
+# Get movie recommendations
+st.markdown("#### What is a Recommendation System?")
+st.markdown("Recommendation systems suggest recommendations to users depending on a variety of criteria.")
+st.markdown('''There are 3 types of recommendation systems:
+1. Demographic Filtering: The recommendations are the same for every user. They are generalized, not personalized. These types of systems are behind sections like *Top Trending*.
+2. Content-based Filtering: These suggest recommendations based on the item metadata (movie, product, song, etc). Here, the main idea is if a user likes an item, then the user will also like items similar to it.
+3. Collaboration-based Filtering: These systems make recommendations by grouping the users with similar interests. For this system, metadata of the item is not required.
+''')
+st.markdown("In this project, we are building a **Content-based** recommendation engine for movies titles.")
+tmdb_data_url = "https://www.kaggle.com/datasets/tmdb/tmdb-movie-metadata"
+st.markdown("To build this recommendation system, we will be using almost 5k movies and credits from the TMDB dataset available at [Kaggle](%s)" % tmdb_data_url)
+
+st.divider()
+
+st.markdown("Enter the title of a movie to see a list of 10 recommendations (e.g. The Dark Knight Rises, The Avengers, etc)")
+title = st.text_input("Movie Title")
+if title != "":
+    movies = get_recommendations(title)
+    if len(movies) > 0:
+        output = ''
+        count = 1
+        for m in movies:
+            output += f"{count}. {m}\n"
+            count += 1
+        st.markdown(output)
+    else:
+        st.warning(f"Unable to find a movie matching title: {title}")

projects/04_Weather_Classification.py

@@ -0,0 +1,60 @@
+import streamlit as st
+import pandas as pd
+import pickle
+import sklearn
+from PIL import Image
+
+@st.cache_resource
+def load_model():
+    model_file = open('./models/weather_prediction_model.pkl', 'rb')
+    rfc = pickle.load(model_file)
+    oe = pickle.load(model_file)
+    sc = pickle.load(model_file)
+    images = pickle.load(model_file)
+    model_file.close()
+    return rfc, oe, sc, images
+
+@st.cache_data
+def load_icons():
+    dz = Image.open("assets/drizzle.png")
+    rn = Image.open("assets/rain.png")
+    sn = Image.open("assets/sun.png")
+    sw = Image.open("assets/snow.png")
+    fg = Image.open("assets/fog.png")
+    return dz, rn, sn, sw, fg
+
+@st.cache_data
+def get_prediction(input):
+    if len(input) != 4:
+        return None
+    input = pd.DataFrame([input], columns = ['precipitation', 'temp_max', 'temp_min', 'wind'])
+    X_predict = sc.transform(input)
+    y_predict = [rfc.predict(X_predict)]
+    weather_predict = oe.inverse_transform(y_predict)[0]
+    return weather_predict[0]
+
+# Load the Model
+rfc, oe, sc, images = load_model()
+
+# Load the Icons
+dz, rn, sn, sw, fg = load_icons()
+
+st.header('Weather Classification', divider='green')
+
+st.markdown("Change the sliders below to see the classification")
+
+# Get input parameters
+precipitation = st.slider('Precipitation (mm)', 0.0, 100.0, 0.0, 1.0)
+temp_min = st.slider('Minimum Temperature (C)', -10.0, 20.0, 8.0, 1.0)
+temp_max = st.slider('Maximum Temperature (C)', -2.0, 40.0, 15.0, 1.0)
+wind = st.slider('Wind Speed (m/s)', 0.0, 10.0, 3.0, 1.0)
+
+# Get weather prediction
+weather = get_prediction([precipitation, temp_min, temp_max, wind])
+if weather == None:
+    st.warning("Unknown Weather Classification")
+else:
+    icon = Image.open(images[weather])
+
+st.info("Weather Classification:")
+st.image(icon, caption = weather, width = 250)

projects/05_Stock_Market.py

@@ -0,0 +1,159 @@
+import streamlit as st
+import pickle
+import plotly.graph_objects as go
+from PIL import Image
+
+@st.cache_resource
+def load_model():
+    model_file = open('./models/stock_market_model.pkl', 'rb')
+    amazon_predictions = pickle.load(model_file)
+    amazon_scores = pickle.load(model_file)
+    google_predictions = pickle.load(model_file)
+    google_scores = pickle.load(model_file)
+    ibm_predictions = pickle.load(model_file)
+    ibm_scores = pickle.load(model_file)
+    microsoft_predictions = pickle.load(model_file)
+    microsoft_scores = pickle.load(model_file)
+    model_file.close()
+    return amazon_predictions, amazon_scores, google_predictions, google_scores, ibm_predictions, ibm_scores, microsoft_predictions, microsoft_scores
+
+# Load Image
+gru = Image.open("assets/gru.png")
+nn = Image.open("assets/nn.png")
+
+# Load the Model
+amazon_predictions, amazon_scores, google_predictions, google_scores, ibm_predictions, ibm_scores, microsoft_predictions, microsoft_scores = load_model()
+
+st.header('Stock Market Forecast', divider='green')
+
+st.markdown("#### Time Series Forecasting")
+st.markdown("Time series forecasting uses information regarding historical values and associated patterns to predict future activity. Most often, this relates to trend analysis, cyclical fluctuation analysis, and issues of seasonality. As with all forecasting methods, success is not guaranteed.")
+
+st.markdown("#### GRU Model")
+st.markdown("Gated recurrent unit is essentially a simplified LSTM. It has the exact same role in the network. The main difference is in the number of gates and weights — GRU is somewhat simpler. It has 2 gates. Since it does not have an output gate, there is no control over the memory content. The update gate controls the information flow from the previous activation, and the addition of new information as well, while the reset gate is inserted into the candidate activation.")
+
+st.image(gru, caption = "Gated Recurrent Unit (GRU)")
+
+st.markdown("Below are the analyses of four stocks using a GRU-based model: *Amazon*, *Google*, *IBM* and *Microsoft*")
+st.markdown("The model consists of the following: A single input and output dimension (i.e. Closing Price) and two hidden layers, with 32 GRU nodes per layer. These models were trained for 105 epochs each.")
+st.image(nn, caption = "GRU-based Model")
+
+st.divider()
+
+st.markdown("Below each graph is the mean square error (MSE) for the train and test sets, where the test set consists of the last 20 days.")
+
+fig1 = go.Figure()
+fig1.add_trace(go.Scatter(go.Scatter(x=amazon_predictions['Date'], y=amazon_predictions['Train Prediction'],
+                    mode='lines',
+                    name='Train Prediction')))
+fig1.add_trace(go.Scatter(x=amazon_predictions['Date'], y=amazon_predictions['Test Prediction'],
+                    mode='lines',
+                    name='Test Prediction'))
+fig1.add_trace(go.Scatter(go.Scatter(x=amazon_predictions['Date'], y=amazon_predictions['Actual Value'],
+                    mode='lines',
+                    name='Actual Value')))
+fig1.update_layout(
+    title="Amazon Stock Prediction",
+    xaxis_title="Date",
+    yaxis_title="Close (USD)",
+    showlegend=True,
+    template = 'plotly_dark'
+)
+
+annotations = []
+annotations.append(dict(xref='paper', yref='paper', x=0.0, y=1.05,
+                              xanchor='left', yanchor='bottom',
+                              text='',
+                              showarrow=False))
+fig1.update_layout(annotations=annotations)
+st.plotly_chart(fig1, use_container_width=True)
+
+# MSE on train and test sets
+st.markdown(f"Train MSE: {amazon_scores[0]:.3f}, Test MSE: {amazon_scores[1]:.3f}")
+
+fig2 = go.Figure()
+fig2.add_trace(go.Scatter(go.Scatter(x=google_predictions['Date'], y=google_predictions['Train Prediction'],
+                    mode='lines',
+                    name='Train Prediction')))
+fig2.add_trace(go.Scatter(x=google_predictions['Date'], y=google_predictions['Test Prediction'],
+                    mode='lines',
+                    name='Test Prediction'))
+fig2.add_trace(go.Scatter(go.Scatter(x=google_predictions['Date'], y=google_predictions['Actual Value'],
+                    mode='lines',
+                    name='Actual Value')))
+fig2.update_layout(
+    title="Google Stock Prediction",
+    xaxis_title="Date",
+    yaxis_title="Close (USD)",
+    showlegend=True,
+    template = 'plotly_dark'
+)
+
+annotations = []
+annotations.append(dict(xref='paper', yref='paper', x=0.0, y=1.05,
+                              xanchor='left', yanchor='bottom',
+                              text='',
+                              showarrow=False))
+fig2.update_layout(annotations=annotations)
+st.plotly_chart(fig2, use_container_width=True)
+
+# MSE on train and test sets
+st.markdown(f"Train MSE: {google_scores[0]:.3f}, Test MSE: {google_scores[1]:.3f}")
+
+fig3 = go.Figure()
+fig3.add_trace(go.Scatter(go.Scatter(x=ibm_predictions['Date'], y=ibm_predictions['Train Prediction'],
+                    mode='lines',
+                    name='Train Prediction')))
+fig3.add_trace(go.Scatter(x=ibm_predictions['Date'], y=ibm_predictions['Test Prediction'],
+                    mode='lines',
+                    name='Test Prediction'))
+fig3.add_trace(go.Scatter(go.Scatter(x=ibm_predictions['Date'], y=ibm_predictions['Actual Value'],
+                    mode='lines',
+                    name='Actual Value')))
+fig3.update_layout(
+    title="IBM Stock Prediction",
+    xaxis_title="Date",
+    yaxis_title="Close (USD)",
+    showlegend=True,
+    template = 'plotly_dark'
+)
+
+annotations = []
+annotations.append(dict(xref='paper', yref='paper', x=0.0, y=1.05,
+                              xanchor='left', yanchor='bottom',
+                              text='',
+                              showarrow=False))
+fig3.update_layout(annotations=annotations)
+st.plotly_chart(fig3, use_container_width=True)
+
+# MSE on train and test sets
+st.markdown(f"Train MSE: {ibm_scores[0]:.3f}, Test MSE: {ibm_scores[1]:.3f}")
+
+fig4 = go.Figure()
+fig4.add_trace(go.Scatter(go.Scatter(x=microsoft_predictions['Date'], y=microsoft_predictions['Train Prediction'],
+                    mode='lines',
+                    name='Train Prediction')))
+fig4.add_trace(go.Scatter(x=microsoft_predictions['Date'], y=microsoft_predictions['Test Prediction'],
+                    mode='lines',
+                    name='Test Prediction'))
+fig4.add_trace(go.Scatter(go.Scatter(x=microsoft_predictions['Date'], y=microsoft_predictions['Actual Value'],
+                    mode='lines',
+                    name='Actual Value')))
+fig4.update_layout(
+    title="Microsoft Stock Prediction",
+    xaxis_title="Date",
+    yaxis_title="Close (USD)",
+    showlegend=True,
+    template = 'plotly_dark'
+)
+
+annotations = []
+annotations.append(dict(xref='paper', yref='paper', x=0.0, y=1.05,
+                              xanchor='left', yanchor='bottom',
+                              text='',
+                              showarrow=False))
+fig4.update_layout(annotations=annotations)
+st.plotly_chart(fig4, use_container_width=True)
+
+# MSE on train and test sets
+st.markdown(f"Train MSE: {microsoft_scores[0]:.3f}, Test MSE: {microsoft_scores[1]:.3f}")

projects/06_Generative_Music.py

@@ -0,0 +1,177 @@
+import streamlit as st
+import io
+import pickle
+import pretty_midi
+import numpy as np
+from music21 import instrument, note, stream, chord
+from keras.saving import load_model
+from scipy.io import wavfile
+
+@st.cache_resource
+def load_notes():
+    notes_filepath = 'models/music_notes.pkl'
+    with open(notes_filepath, 'rb') as filepath:
+        notes = pickle.load(filepath)
+        pitchnames = pickle.load(filepath)
+        n_vocab = pickle.load(filepath)
+    return (notes, pitchnames, n_vocab)
+
+@st.cache_resource
+def model_load():
+    model_filepath = 'models/music_model.keras'
+    model = load_model(model_filepath)
+    return model
+
+@st.cache_data
+def prepare_sequences(notes, pitchnames, n_vocab, sequence_length=100):
+    note_to_int = dict((note, number) for number, note in enumerate(pitchnames))
+
+    network_input = []
+    for i in range(0, len(notes) - sequence_length, 1):
+        sequence_in = notes[i:i + sequence_length]
+        sequence_out = notes[i + sequence_length]
+        network_input.append([note_to_int[char] for char in sequence_in])
+
+    return network_input
+
+def generate_notes(model, network_input, pitchnames, n_vocab, nlength, istart=-1):
+    # pick a random sequence from the input as a starting point for the prediction
+    if istart < 0 or istart > len(network_input) - 1:
+        start = np.random.randint(0, len(network_input) - 1)
+        print(f"Starting Position = {start}")
+    else:
+        start = istart
+
+    int_to_note = dict((number, note) for number, note in enumerate(pitchnames))
+
+    pattern = network_input[start]
+    prediction_output = []
+
+    # generate nlength notes
+    for note_index in range(nlength):
+        prediction_input = np.reshape(pattern, (1, len(pattern), 1))
+        prediction_input = prediction_input / float(n_vocab)
+
+        prediction = model.predict(prediction_input, verbose=0)
+
+        index = np.argmax(prediction)
+        result = int_to_note[index]
+        prediction_output.append(result)
+
+        pattern.append(index)
+        pattern = pattern[1:len(pattern)]
+
+    return prediction_output
+
+def create_midi(prediction_output, output_filepath):
+    offset = 0
+    output_notes = []
+
+    # create note and chord objects based on the values generated by the model
+    for pattern in prediction_output:
+        # pattern is a chord
+        if ('.' in pattern) or pattern.isdigit():
+            notes_in_chord = pattern.split('.')
+            notes = []
+            for current_note in notes_in_chord:
+                new_note = note.Note(int(current_note))
+                new_note.storedInstrument = instrument.Piano()
+                notes.append(new_note)
+            new_chord = chord.Chord(notes)
+            new_chord.offset = offset
+            output_notes.append(new_chord)
+        # pattern is a note
+        else:
+            new_note = note.Note(pattern)
+            new_note.offset = offset
+            new_note.storedInstrument = instrument.Piano()
+            output_notes.append(new_note)
+
+        # increase offset each iteration so that notes do not stack
+        offset += 0.5
+
+    # Write notes to a MIDI file
+    midi_stream = stream.Stream(output_notes)
+    midi_stream.write('midi', fp='output.mid')
+
+def generate(model, network_input, pitchnames, n_vocab, nlength=500, istart=-1):
+    output_filepath = 'output.mid'
+    if nlength < 1:
+        print(f"Song length must be at least one note, defaulting to 250 notes")
+        nlength = 500
+    if nlength > 500:
+        print(f"Cannot exceed 500 notes for song length")
+        nlength = 500
+
+    prediction_output = generate_notes(model, network_input, pitchnames, n_vocab, nlength, istart)
+    create_midi(prediction_output, output_filepath)
+    return output_filepath
+
+st.header('Generative Music', divider='green')
+
+# Load notes
+notes, pitchnames, n_vocab = load_notes()
+
+# Prepare note sequences
+network_input = prepare_sequences(notes, pitchnames, n_vocab)
+
+# Load model
+model = model_load()
+
+st.markdown("#### What are Recurrent Neural Networks?")
+st.markdown("A recurrent neural network is a class of artificial neural networks that make use of sequential information. They are called recurrent because they perform the same function for every single element of a sequence, with the result being dependent on previous computations. Whereas outputs are independent of previous computations in traditional neural networks.")
+st.markdown("In this project we will use a **Long Short-Term Memory** (LSTM) network. They are a type of Recurrent Neural Network that can efficiently learn via gradient descent. Using a gating mechanism, LSTMs are able to recognise and encode long-term patterns. LSTMs are extremely useful to solve problems where the network has to remember information for a long period of time as is the case in music and text generation.")
+st.markdown("#### Data")
+st.markdown("The data that our model will be trained on will consist of piano MIDI files of Final Fantasy soundtracks, but any set of MIDI files consisting of a single instrument would work.")
+st.markdown("The sequence of notes and chords from the MIDI files are broken down into increments of 100, which are used to predict the next note or chord.")
+st.markdown("#### Model")
+st.markdown("For this project we will use a network consisting of three LSTM layers, three Dropout layers, two Dense layers and one activation layer.")
+st.markdown("It may be possible to improve this model by playing around with the the structure of the network, or adding new categories (e.g. varying note duration, rest periods between notes, etc). However, to achieve satisfying results with more classes we would also have to increase the depth of the LSTM network.")
+st.markdown("*This is based off the tutorial by Sigurður Skúli [How to Generate Music using a LSTM Neural Network in Keras](https://towardsdatascience.com/how-to-generate-music-using-a-lstm-neural-network-in-keras-68786834d4c5)*")
+st.divider()
+
+midi_file = None
+generated_midi = None
+sample_midi = None
+
+st.markdown("You can select one of the samples below")
+
+sample_midi = st.selectbox(
+    'Select a sample MIDI file to play',
+    ('assets/sample_01.mid', 'assets/sample_02.mid', 'assets/sample_03.mid'),
+    index=None,
+    placeholder="Please select a sample...",
+)
+
+st.markdown("Or generate a new sample by clicking the generate button")
+
+n_notes = st.slider("How many notes do you want?", 1, 500, 250)
+start_pos = st.slider("Where do you want to start? Negative will start at a random position.", -1, len(network_input) - 1, -1)
+
+if st.button('Generate'):
+    with st.spinner(f"Generating a new MIDI file"):
+        generated_midi = generate(model, network_input, pitchnames, n_vocab, n_notes, start_pos)
+
+st.divider()
+
+if generated_midi:
+    midi_file = generated_midi
+    sample_midi = None
+elif sample_midi:
+    midi_file = sample_midi
+
+if midi_file:
+    with st.spinner(f"Transcribing to FluidSynth"):
+        midi_data = pretty_midi.PrettyMIDI(midi_file)
+        audio_data = midi_data.fluidsynth()
+        audio_data = np.int16(
+            audio_data / np.max(np.abs(audio_data)) * 32767 * 0.9
+        )  # -- Normalize for 16 bit audio https://github.com/jkanner/streamlit-audio/blob/main/helper.py
+
+        virtualfile = io.BytesIO()
+        wavfile.write(virtualfile, 44100, audio_data)
+
+    st.audio(virtualfile)
+    st.markdown("Download the audio by right-clicking on the media player")
+else:
+    st.markdown("Either generate a new MIDI file, or select one of the samples")

projects/07_LLM_Fine_Tuned.py

@@ -0,0 +1,64 @@
+import streamlit as st
+# from llama_cpp import Llama
+import re
+
+st.header('Fine Tuned LLM', divider='green')
+
+st.markdown("#### What is a LLM?")
+st.markdown("LLM stands for Large Language Model, which are mathematical models trained to predict the next set of words based on the prompt provided to it.")
+st.markdown("In this case we are using [Meta's LLama 3.1 (8B) Instruct](https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct) as our base model.")
+st.markdown("#### What is a fine tuning?")
+st.markdown("Fine tuning is the processes of tweaking the response of the LLM to particular subset of prompts. Most LLMs are trained on a large corpus of generic data, fine tuning just guides the LLM to a specific use case.")
+st.markdown("In this case I have fine tuned the base model on [Microsoft's Orca Math Word Problems](https://huggingface.co/datasets/microsoft/orca-math-word-problems-200k), so the chatbot below is more of math assistant. Though it occasionally gets the wrong answer, it is willing to try again. I only fine tuned on 1000 math word problems, but I could try to train on the entire dataset in the future.")
+st.markdown("#### What is quantization?")
+st.markdown("Most LLM are quite large, often too large to fit into a computer's memory. So ML developers employ Graphic Processing Units (GPUs) with large amounts of memory to train or make use of such LLMs.")
+st.markdown("However not everyone has access to such resources, so quantization is the process of decreasing the size of a model so that it can fit into memory (GPU or CPU). The process of quantization decreases the precision used to store the models parameters, at the cost of the model's accuracy.")
+st.markdown("In this case after I fine tuned the LLama 3.1 (8B) base model, it was quantized to 4 bits which offers reasonable model accuracy at 25% the base model size.")
+st.markdown("*This is based off the tutorial by Abid Ali Awan [Fine-Tuning Llama 3 and Using It Locally: A Step-by-Step Guide](https://www.datacamp.com/tutorial/llama3-fine-tuning-locally)*")
+st.divider()
+
+st.warning("**Work In Progress**")
+
+if "messages" not in st.session_state:
+    st.session_state["messages"] = [{"role": "system", "content": "You are a helpful math assistant."}, {"role": "assistant", "content": "What math problem can I help you with today?"}]
+
+def chat_action(prompt):
+    if len(st.session_state.messages) > 6:
+        st.session_state.messages.pop(2)
+        st.session_state.messages.pop(2)
+    st.session_state["messages"].append({"role": "user", "content": prompt})
+    st.chat_message("user").write(prompt)
+
+    # with st.spinner(f"Generating response"):
+    #     response = llm.create_chat_completion(
+    #         messages=st.session_state.messages,
+    #         temperature = 0.7,
+    #         repeat_penalty = 1.1,
+    #         stop = "[/INST]"
+    #     )
+    #     msg = response['choices'][0]['message']['content']
+    #     msg = re.sub(r'(<<|\[)*(INST|SYS)(>>|\])*', '', msg)
+    #     st.session_state["messages"].append({"role": "assistant", "content": msg})
+    #     st.chat_message("assistant").write(msg)
+
+# @st.cache_resource
+# def load_llm():
+#     #### Import Model from Huggingface
+#     llm = Llama.from_pretrained(
+#         repo_id="ccapo/llama-3.1-8b-chat-math-teacher-GGUF",
+#         filename="*Q4_K_M.gguf",
+#         verbose=False,
+#         n_ctx=2048
+#     )
+#     return llm
+
+for msg in st.session_state.messages:
+    if msg["role"] != "system":
+        with st.chat_message(name=msg["role"]):
+            st.write(msg["content"])
+
+# with st.spinner(f"Loading LLM"):
+#     llm = load_llm()
+
+if prompt := st.chat_input():
+    chat_action(prompt)