Docs: example of multiclass training

[chin-jey]

Hello lambeq dev team!

Can you please consider including an example of a multiclass classification using the QuantumTrainer in the documentation ?

Best regards, Chin.

[dimkart]

Hi, thanks for the suggestion. Yes, we could add an example of multi-label classification and will try to do it in one of the future releases. However have in mind it won't be that different from the binary case. You basically need to:

1. assign to the s wire as many qubits as you need to encode your classes (e.g. for 8 classes you need 3 qubits)
2. encode appropriately the target labels
3. unpack the predictions and use categorical cross entropy as your loss (instead of binary cross entropy).

Hope that helps.

[mspronesti]

@le-big-mac I'm using NumpyModel. Actually, yesterday I opened another thread to better describe what I'm trying to do with tweet data while asking if a compositional approach suits the problem. If you think I'm going off topic here, feel free to move there. Thanks again for you answer!

[mspronesti]

Hello again @le-big-mac, I did what you suggested for the dimensions. However, there's definitely something not working as I have 0.00 accuracy both for training and evaluation and exactly the same loss after every epoch. On the contrary, the binary case works as expected.

Can you tell me at what stage of the pipeline you suggest squashing the dimensions ? I tried doing it in the loss function (code above) just before the return statement, with a reshape.

[le-big-mac]

Apologies for the delay, yes that is where I would suggest doing the reshaping. It's quite strange that it doesn't seem to be working, could you perhaps upload a snippet?

[mspronesti]

@le-big-mac

This is how I'm encoding my labels

from sklearn.preprocessing import OneHotEncoder

_sentiment_categories = [['dummy'], ['negative'], ['neutral'], ['positive']]
enc = OneHotEncoder().fit(_sentiment_categories)

def sentiment_to_label(sentiment: str):
    """Encodes sentiments to a one-hot label given
    an input string.
    Accepted values {'negative', 'neutral', 'positive'}
    """
    try:
        # wrap the string sentiment into a 2d nd-array
        # to comply with sklearn requirements
        feat_sentiment = [[sentiment]]
        return enc.transform(feat_sentiment).toarray().tolist()[0]
    except ValueError:
        print(f"Sentiment {sentiment} is not valid")

I'm using spiders_reader as parser

from lambeq import spiders_reader

# Create string diagrams based on spiders reader
spiders_diagram = spiders_reader.sentence2diagram(sentence)

this is my ansatz

ansatz = IQPAnsatz({AtomicType.NOUN: 1,
                                    AtomicType.SENTENCE: 2},
                                   n_layers=1, n_single_qubit_params=3)

I'm using the above cross-entropy loss, but reshaping before the return statement.

def cross_entropy(predictions, targets, epsilon=1e-12):
    predictions = np.clip(predictions, epsilon, 1. - epsilon)
    N = predictions.shape[0]
    ####### HERE: reshape to (N, 4) ##############
    predictions = predictions.reshape(N, targets.shape[1]) 
    ########################################
    return -np.sum(targets*np.log(predictions+1e-9))/N

I didn't change anything else from the tutorial (except the dataset, of course).

It seems like that the optimizer is not doing anything, as my losses stay the same after each step. So do the accuracies.

[mspronesti]

Hello again @le-big-mac ,
I guess the way the accuracy is computed needs to be changed as well, as now we have arrays of size 4. This is how I changed it to generalize to the N case:

def acc(y_hat, y_):
    y_hat = y_hat.reshape(y_hat.shape[0], y_.shape[1])
    return accuracy_score(y_true=np.argmax(y_, axis=1), y_pred=np.argmax(y_hat, axis=1))

however the loss doesn't change. Seems like the optimizer is not optimizing. Perhaps the configuration of SPSA shown in the tutorial does not fit my case ? I even tried several learning rates and scalings, to no avail.

Maybe you can elaborate a little more on why squashing the two dimensions yields the correct output ? For instance, in a neural network fed with one-hot encoded labels (e.g. size 4) I expect an output like this one (just inventing an example)

[.1, .87, .02, 0.1]

and so the prediction is correct if the label was [0, 1, 0, 0]. Why do these models output a different format and why squashing it is correct ?

What if I used a different parser, e.g. Bobcat for which I see I have outputs of unexpected (from me) sizes depending on N, C, P. Can y9u please help me understanding it ?