Simon's questions

Eu tenho este exemplo de Polars DataFrame:

import polars as pl 

df = pl.DataFrame({
    "id": [1, 2, 3, 4, 5],
    "variable1": [15, None, 5, 10, 20],
    "variable2": [40, 30, 50, 10, None],
}) 

Estou tentando filtrar todas as colunas do meu dataframe usando o método pl.all(), e também tentei usar pl.any_horizontal() == Condition. No entanto, estou recebendo o seguinte erro:

ComputeError: The predicate passed to 'LazyFrame.filter' expanded to multiple expressions: 

    col("id").is_not_null(),
    col("variable1").is_not_null(),
    col("variable2").is_not_null(),
This is ambiguous. Try to combine the predicates with the 'all' or `any' expression.

Aqui estão minhas tentativas de enfrentar isso.

# Attempt 1:
(
    df
    .filter(
        pl.all().is_not_null()
    )
)
# Attempt 2:
(
    df
    .filter(
        pl.any_horizontal().is_not_null()
    )
)

Saída desejada, mas não é escalável para DataFrames maiores:

(
    df
    .filter(
        pl.col("variable1").is_not_null(),
        pl.col("variable2").is_not_null()
    )
)

Como posso filtrar todas as colunas de forma escalável sem especificar cada coluna individualmente?

Estou usando Polars para processar um DataFrame para poder salvá-lo como JSON. Sei que posso usar o método .write_json(), no entanto, gostaria de adicionar um novo nível ao JSON.

Minha abordagem atual:

import polars as pl


df = pl.DataFrame({
    "id": [1, 2, 3, 4, 5],
    "variable1": [15, 25, 5, 10, 20],
    "variable2": [40, 30, 50, 10, 20],
}) 
(
    df.write_json()
)

Saída de corrente:

'[{"id":1,"variable1":15,"variable2":40},{"id":2,"variable1":25,"variable2":30},{"id":3,"variable1":5,"variable2":50},{"id":4,"variable1":10,"variable2":10},{"id":5,"variable1":20,"variable2":20}]'

Mas eu gostaria de salvá-lo dessa forma, com a chave "Befs", para que cada "Befs" contenha todos os registros do DataFrame.

Saída desejada:

{
    "Befs": [
        {
            "ID ": 1,
            "variable1": 15,
            "variable2": 40
        },
        {
            "ID ": 2,
            "variable1": 25,
            "variable2": 30
        }

    ]
}

Tentei usar .pl.struct(), mas minhas tentativas não fazem sentido:

(
    df
    .select(
        pl.struct(
            pl.lit("Bef").alias("Bef"),
            pl.col("id"),
            pl.col("variable1"),
            pl.col("variable2")
        )
    )
    .write_json()
)

Tenho um Polars DataFrame onde cada id pode aparecer várias vezes com valores de estado diferentes (1 ou 2). Quero contar quantos ids exclusivos têm apenas o estado 1, apenas o estado 2 ou ambos os estados 1 e 2.

import polars as pl

df = pl.DataFrame({
    "id": [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 20, 20, 20],
    "state": [1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 2, 1, 1, 2, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2]
})

Quero contar quantos IDs exclusivos se enquadram em cada categoria:

• Apenas indique 1 (por exemplo, IDs que têm apenas 1)

• Apenas indique 2 (por exemplo, IDs que tenham apenas 2)

• Ambos os estados 1 e 2 (por exemplo, IDs que têm 1 e 2)

Resultado esperado (exemplo):

State combination [1]  -> 20 IDs  
State combination [2]  -> 15 IDs  
State combination [1, 2]  -> 30 IDs  

Tenho um Polars DataFrame e quero criar uma visualização resumida onde valores agregados (por exemplo, IDs exclusivos, envios totais) são exibidos em um formato que facilita a comparação entre meses. Aqui está um exemplo do meu conjunto de dados:

Meu exemplo de dataframe:

import polars as pl
df = pl.DataFrame({
    "Channel": ["X", "X", "Y", "Y", "X", "X", "Y", "Y", "X", "X", "Y", "Y", "X", "X", "Y", "Y"],
    "ID": ["a", "b", "b", "a", "e", "b", "g", "h", "a", "a", "k", "a", "b", "n", "o", "p"],
    "Month": ["1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2"]
})

Atualmente, uso a seguinte group_by()abordagem para calcular o número de IDs exclusivos e o número total de envios para cada mês e canal:

(
    df
    .group_by(
        pl.col("Month"),
        pl.col("Channel")
    )
    .agg(
        pl.col("ID").n_unique().alias("Uniques ID"),
        pl.col("ID").len().alias("Total sends")
    )
)
shape: (4, 4)
┌───────┬─────────┬────────────┬─────────────┐
│ Month ┆ Channel ┆ Uniques ID ┆ Total sends │
│ ---   ┆ ---     ┆ ---        ┆ ---         │
│ str   ┆ str     ┆ u32        ┆ u32         │
╞═══════╪═════════╪════════════╪═════════════╡
│ 1     ┆ X       ┆ 3          ┆ 4           │
│ 1     ┆ Y       ┆ 4          ┆ 4           │
│ 2     ┆ X       ┆ 3          ┆ 4           │
│ 2     ┆ Y       ┆ 3          ┆ 4           │
└───────┴─────────┴────────────┴─────────────┘

No entanto, meu conjunto de dados real é muito maior e tem mais agg_functions, então eu quero um formato que destaque melhor as comparações entre meses. Idealmente, eu quero que a saída fique assim:

| Channels | agg_func     | months | months |
|----------|--------------|--------|--------|
|          |              | 1      | 2      |
| X        | Uniques ID   | 3      | 3      |
| X        | Total sends  | 4      | 4      |
| Y        | Uniques ID   | 4      | 3      |
| Y        | Total sends  | 4      | 4      |

Acredito que eu poderia usar .pivot()e passar as funções de agregação como parte do índice. Mas, não tenho certeza de como implementar isso diretamente sem criar um DataFrame auxiliar. Alguma sugestão?

Tenho um dataframe com vários IDs e estados correspondentes. Quero analisar como os estados mudaram ao longo do tempo e apresentar essas informações de forma eficaz.

Aqui está um exemplo:

import polars as pl

df = pl.DataFrame({
    "ID": [1, 2, 3],
    "T0": ["A", "B", "C"],
    "T1": ["B", "B", "A"],  
})

Uma abordagem é "concatenar" as colunas e, em seguida, fazer uma value_counts()alteração na coluna

df = df.with_columns(
    (pl.col("T0") + " -> " + pl.col("T1")).alias("Change")
)

No entanto, pode haver uma abordagem melhor para isso, ou até mesmo uma função integrada que possa realizar o que preciso com mais eficiência.

Saída de corrente:

shape: (3, 4)
┌─────┬─────┬─────┬────────┐
│ ID  ┆ T0  ┆ T1  ┆ Change │
│ --- ┆ --- ┆ --- ┆ ---    │
│ i64 ┆ str ┆ str ┆ str    │
╞═════╪═════╪═════╪════════╡
│ 1   ┆ A   ┆ B   ┆ A -> B │
│ 2   ┆ B   ┆ B   ┆ B -> B │
│ 3   ┆ C   ┆ A   ┆ C -> A │
└─────┴─────┴─────┴────────┘

shape: (3, 2)
┌────────┬───────┐
│ Change ┆ count │
│ ---    ┆ ---   │
│ str    ┆ u32   │
╞════════╪═══════╡
│ C -> A ┆ 1     │
│ B -> B ┆ 1     │
│ A -> B ┆ 1     │
└────────┴───────┘

Tenho um dataframe polars que contém um ID, DATA e SO. Para cada dia, gostaria de contar quantos IDs únicos existem até aquele dia.

import polars as pl
df = (
    pl.DataFrame(
        {
            "DAY": [1,1,1,2,2,2,3,3,3],
            "OS" : ["A","B","A","B","A","B","A","B","A"],
            "ID": ["X","Y","Z","W","X","J","K","L","X"]
        }
    )
)

Saída desejada:

shape: (3, 3)
┌─────┬─────┬─────┐
│ DAY ┆ A   ┆ B   │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╡
│ 1   ┆ 2   ┆ 1   │
│ 2   ┆ 2   ┆ 3   │
│ 3   ┆ 3   ┆ 4   │
└─────┴─────┴─────┘

Deveria ficar assim, porque no dia 1, há 3 valores e 3 IDs. No dia 2, o ID "X" é repetido com o mesmo SO, então, as colunas A permanecem as mesmas, e as outras 2 são diferentes, então adicione 2 a B. No dia 3, o ID X é repetido com A, e as outras 2 são diferentes, então ele soma novamente sobre cada coluna.

Acredito que isso poderia ser resolvido com uma abordagem como a seguinte:

(
    df
    .pivot(
        index="DAY",
        on="OS",
        aggregate_function=(pl.col("ID").cum_sum().unique())
    )
)

Estou tentando usar o scikit-learn LabelEncodercom um Polars DataFrame para codificar uma coluna categórica. Estou usando o seguinte código.

import polars as pl

from sklearn.preprocessing import LabelEncoder

df = pl.DataFrame({
    "Color" : ["red","white","blue"]
})

enc = LabelEncoder()

Entretanto, um erro é gerado.

ValueError: y should be a 1d array, got an array of shape () instead.

Em seguida, tentei converter a coluna em um NumPy.

df.with_columns(
    enc.fit_transform(pl.col("Color").to_numpy()) 
)

Agora, um erro diferente é gerado.

AttributeError: 'Expr' object has no attribute 'to_numpy'

Nota. Descobri que isso .cast(pl.Categorical).to_physical()poderia ser usado para obter o resultado desejado. Ainda assim, eu preferiria usar algo como transform()no meu conjunto de dados de teste.

df.with_columns(
    pl.col("Color").cast(pl.Categorical).to_physical().alias("Color_encoded")
)

Estou trabalhando em uma tarefa de classificação de texto e decidi usar um modelo PyTorch para esse propósito. O processo envolve principalmente as seguintes etapas:

1. Carregue e processe o texto.
2. Use um vetorizador TF-IDF.
3. Crie a rede neural e salve o TF-IDF Vectorizer e o modelo para prever novos dados.

No entanto, todos os dias preciso classificar novos comentários e corrigir quaisquer classificações erradas.

Atualmente, minha abordagem é adicionar os novos comentários com a classificação correta ao conjunto de dados e treinar novamente o modelo inteiro. Esse processo é demorado, e os novos comentários podem ser perdidos durante a validação. Gostaria de criar um novo conjunto de dados com os textos recém-classificados e continuar treinando sobre esses novos dados (os novos comentários são classificados manualmente, então cada rótulo está correto).

Usando GPT e algum código online, escrevo o processo desejado, no entanto, não tenho certeza se está funcionando como esperado ou se estou cometendo alguns erros bobos que não deveriam acontecer.

Então as principais questões são:

1. Como posso verificar se a maneira proposta para resolver esse problema funciona como eu espero?
2. O que posso fazer com o vetorizador quando ele enfrenta novos tokens? Posso simplesmente fazer isso .fit_transform()ou perderei o vetorizador original?

Aqui está o processo completo de treinamento:

import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader, random_split
from sklearn.preprocessing import LabelEncoder
import polars as pl
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
import joblib

set1 = (
    pl
    .read_csv(
        "set1.txt",
        separator=";",
        has_header=False,
        new_columns=["text","label"]
    )
)

# since the dateset its unbalanced, im going to force to have more balance

fear_df = set1.filter(pl.col("label") == "fear")
joy_df = set1.filter(pl.col("label") == "joy").sample(n=2500)
sadness_df = set1.filter(pl.col("label") == "sadness").sample(n=2500)
anger_df = set1.filter(pl.col("label") == "anger")

train_df = pl.concat([fear_df,joy_df,sadness_df,anger_df])

"""
The text its already clean, so im going to change the labels to numeric
and then split it on train, test ,val
"""

label_mapping = {
    "anger": 0,
    "fear": 1,
    "joy": 2,
    "sadness": 3
}

train_mapped = (
    train_df
    .with_columns(
        pl.col("label").replace_strict(label_mapping, default="other").cast(pl.Int16)
    )
   
)

train_set, pre_Test = train_test_split(train_mapped,
                                    test_size=0.4,
                                    random_state=42,
                                    stratify=train_mapped["label"])

test_set, val_set = train_test_split(pre_Test,
                                    test_size=0.5,
                                    random_state=42,
                                    stratify=pre_Test["label"]) 

# Vectorize text data using TF-IDF
vectorizer = TfidfVectorizer(max_features=30000, ngram_range=(1, 2))

X_train_tfidf = vectorizer.fit_transform(train_set['text']).toarray()
X_val_tfidf = vectorizer.transform(val_set['text']).toarray()
X_test_tfidf = vectorizer.transform(test_set['text']).toarray()

y_train = train_set['label']
y_val = val_set['label']
y_test = test_set['label']

class TextDataset(Dataset):
    def __init__(self, texts, labels):
        self.texts = texts
        self.labels = labels
    
    def __len__(self):
        return len(self.texts)
    
    def __getitem__(self, idx):
        text = self.texts[idx]
        label = self.labels[idx]
        return text, label
    
train_dataset = TextDataset(X_train_tfidf, y_train)
val_dataset = TextDataset(X_val_tfidf, y_val)
test_dataset = TextDataset(X_test_tfidf, y_test)

batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size)
test_loader = DataLoader(test_dataset, batch_size=batch_size)

class TextClassificationModel(nn.Module):
    def __init__(self, input_dim, num_classes):
        super(TextClassificationModel, self).__init__()
        self.fc1 = nn.Linear(input_dim, 64)
        self.dropout1 = nn.Dropout(0.5)
        self.fc2 = nn.Linear(64, 32)
        self.dropout2 = nn.Dropout(0.5)
        self.fc3 = nn.Linear(32, num_classes)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout1(x)
        x = torch.relu(self.fc2(x))
        x = self.dropout2(x)
        x = torch.softmax(self.fc3(x), dim=1)
        return x
    
input_dim = X_train_tfidf.shape[1]
model = TextClassificationModel(input_dim, 4)

# Define loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adamax(model.parameters())

# Training loop
num_epochs = 17
best_val_acc = 0.0
best_model_path = "modelbest.pth"

for epoch in range(num_epochs):
    model.train()
    for texts, labels in train_loader:
        texts, labels = texts.float(), labels.long()
        outputs = model(texts)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # Validation
    model.eval()
    correct, total = 0, 0
    with torch.no_grad():
        for texts, labels in val_loader:
            texts, labels = texts.float(), labels.long()
            outputs = model(texts)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    val_acc = correct / total
    if val_acc > best_val_acc:
        best_val_acc = val_acc
        torch.save(model.state_dict(), best_model_path)

    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}, Val Acc: {val_acc:.4f}')

# Load the best model
model.load_state_dict(torch.load(best_model_path))

# Load the best model
model.load_state_dict(torch.load(best_model_path))

# Test the model
model.eval()
correct, total = 0, 0
with torch.no_grad():
    for texts, labels in test_loader:
        texts, labels = texts.float(), labels.long()
        outputs = model(texts)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
test_acc = correct / total
print(f'Test Acc: {test_acc:.3f}')


# Save the TF-IDF vectorizer
vectorizer_path = "tfidf_vectorizer.pkl"
joblib.dump(vectorizer, vectorizer_path)

# Save the PyTorch model
model_path = "text_classification_model.pth"
torch.save(model.state_dict(), model_path)

Código proposto:

import torch
import joblib
import polars as pl
from sklearn.model_selection import train_test_split
from torch import nn
from torch.utils.data import Dataset, DataLoader

# Load the saved TF-IDF vectorizer
vectorizer_path = "tfidf_vectorizer.pkl"
vectorizer = joblib.load(vectorizer_path)

input_dim = len(vectorizer.get_feature_names_out())

class TextClassificationModel(nn.Module):
    def __init__(self, input_dim, num_classes):
        super(TextClassificationModel, self).__init__()
        self.fc1 = nn.Linear(input_dim, 64)
        self.dropout1 = nn.Dropout(0.5)
        self.fc2 = nn.Linear(64, 32)
        self.dropout2 = nn.Dropout(0.5)
        self.fc3 = nn.Linear(32, num_classes)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout1(x)
        x = torch.relu(self.fc2(x))
        x = self.dropout2(x)
        x = torch.softmax(self.fc3(x), dim=1)
        return x
    
# Load the saved PyTorch model
model_path = "text_classification_model.pth"
model = TextClassificationModel(input_dim, 4)
model.load_state_dict(torch.load(model_path))

# Map labels to numeric values
label_mapping = {"anger": 0, "fear": 1, "joy": 2, "sadness": 3}
sentiments = ["fear","joy","sadness","anger"]

new_data = (
    pl
    .read_csv(
        "set2.txt",
        separator=";",
        has_header=False,
        new_columns=["text","label"]
    )
    .filter(pl.col("label").is_in(sentiments))
    .with_columns(
        pl.col("label").replace_strict(label_mapping, default="other").cast(pl.Int16)
    )
    
)
# Vectorize the new text data using the loaded TF-IDF vectorizer
X_new = vectorizer.transform(new_data['text']).toarray()
y_new = new_data['label']

class TextDataset(Dataset):
    def __init__(self, texts, labels):
        self.texts = texts
        self.labels = labels
    
    def __len__(self):
        return len(self.texts)
    
    def __getitem__(self, idx):
        text = self.texts[idx]
        label = self.labels[idx]
        return text, label

batch_size = 10
   
# Create DataLoader for the new training data
new_train_dataset = TextDataset(X_new, y_new)
new_train_loader = DataLoader(new_train_dataset, batch_size=batch_size, shuffle=True)

# Define loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adamax(model.parameters())

num_epochs = 5
new_best_model_path = "modelbest.pth"
for epoch in range(num_epochs):
    model.train()
    for texts, labels in new_train_loader:
        texts, labels = texts.float(), labels.long()
        outputs = model(texts)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        torch.save(model.state_dict(), new_best_model_path)
        
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# Save the PyTorch model
new_best_model_path = "new_moedl.pth"
torch.save(model.state_dict(), new_best_model_path)

O conjunto de dados pode ser encontrado aqui

Estou tentando truncar números de ponto flutuante em meu DataFrame para um número desejado de casas decimais. Descobri que isso pode ser feito usando Pandas e NumPy aqui , mas também vi que pode ser possível com polars.Config.set_float_precision.

Abaixo está minha abordagem atual, mas acho que posso tomar medidas extras.

import polars as pl

data = {
    "name": ["Alice", "Bob", "Charlie"],
    "grade": [90.23456, 80.98765, 85.12345],
}

df = pl.DataFrame(data)
df.with_columns(
# Convert to string
    pl.col("grade").map_elements(lambda x: f"{x:.5f}", return_dtype=pl.String).alias("formatted_grade")
).with_columns(
# Slice to get my desired decimals
    pl.col("formatted_grade").str.slice(0, length = 4)
).with_columns(
# Convert it again to Float
    pl.col("formatted_grade").cast(pl.Float64)
)

Eu tenho um script Python que carrega termos de pesquisa de um arquivo JSON e processa um DataFrame do Pandas para adicionar novas colunas indicando se determinados termos estão presentes nos dados de texto. No entanto, gostaria de modificar o script para usar Polars em vez de Pandas e possivelmente remover a dependência JSON. Aqui está meu código original:

import pandas as pd
import json


class SearchTermLoader:
    def __init__(self, json_file):
        self.json_file = json_file

    def load_terms(self):
        with open(self.json_file, 'r') as f:
            data = json.load(f)

        terms = {}
        for phase_name, phase_data in data.items():
            terms[phase_name] = (
                phase_data.get('words', []),
                phase_data.get('exact_phrases', [])
            )
        return terms

class DataFrameProcessor:
    def __init__(self, df: pd.DataFrame, col_name: str) -> None:
        self.df = df
        self.col_name = col_name

    def add_contains_columns(self, search_terms):
        columns_to_add = ["type1", "type2"]
        for column in columns_to_add:
            self.df[column] = self.df[self.col_name].apply(
                lambda text: any(
                    term in text
                    for term in search_terms.get(column, ([], []))[0] + search_terms.get(column, ([], []))[1]
                )
            )
        return self.df

# Example Usage
data = {'text_column': ['The apple is red', 'I like bananas', 'Cherries are tasty']}
df = pd.DataFrame(data)

term_loader = SearchTermLoader('word_list.json')
search_terms = term_loader.load_terms()

processor = DataFrameProcessor(df, 'text_column')
new_df = processor.add_contains_columns(search_terms)

new_df     

Aqui está um exemplo do arquivo json:

{
    "type1": {
        "words": ["apple", "tasty"],
        "exact_phrases": ["soccer ball"] 
    },
    "type2": {
        "words": ["banana"],
        "exact_phrases": ["red apple"]
    }
}

Entendo que posso usar a .str.contains()função, mas quero usá-la com palavras específicas e frases exatas. Você poderia fornecer alguma orientação sobre como começar com isso?