<jupyter_start><jupyter_text>Hackaton Desafio Budokai Equipe 11  notebook_v2: A ideia principal nesta versão é utilizar os dados mensais (média, desvio, max e min) como entrada no modelo de previsão da produção anual de soja.  Bibliotecas:<jupyter_code>#importanto bibliotecas

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from sklearn import datasets, linear_model, preprocessing

import statsmodels.api as sm
from sklearn.metrics import mean_squared_error, r2_score

from sklearn.preprocessing import StandardScaler
from datetime import datetime

from sklearn.linear_model import Lasso, LassoCV
from sklearn.impute import SimpleImputer

from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error as MSE
from sklearn.model_selection import train_test_split<jupyter_output><empty_output><jupyter_text>Lendo csv e removendo algumas colunas redundantes:<jupyter_code>Y_train=pd.read_csv('shared/bases_budokai_ufpr/produtividade_soja_modelagem.csv')
df=pd.read_csv('shared/bases_budokai_ufpr/agroclimatology_budokai.csv')
Y_train.head()
Y_train['nivel'].unique()
#Y_codigo=Y_train['codigo_ibge']

Y_train=Y_train.drop(columns=['nivel', 'name'])
Y_train.head()<jupyter_output><empty_output><jupyter_text>De acordo com as respostas esperadas temos:<jupyter_code>codigo_saida=[4102000,4104303,4104428,4104808,4104907,4109401,4113205,4113700,4113734,4114005,4114401,4117701,4117909,4119608,4119905,4127007,4127403,4127502,4127700,4128005
]
dataset=pd.DataFrame(columns=df.keys())
#dataset.loc[dataset['codigo_ibge']==codigo_saida[j]]

for k in codigo_saida:
    dataset=pd.concat([df.loc[df['codigo_ibge']==k],dataset])

dataset=dataset.reset_index(drop=True)
dataset.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
RangeIndex: 131500 entries, 0 to 131499
Data columns (total 38 columns):
 #   Column               Non-Null Count   Dtype  
---  ------               --------------   -----  
 0   data                 131500 non-null  object 
 1   codigo_ibge          131500 non-null  object 
 2   latitude             131500 non-null  float64
 3   longitude            131500 non-null  float64
 4   T2M_RANGE            131500 non-null  float64
 5   TS                   131500 non-null  float64
 6   T2MDEW               131500 non-null  float64
 7   T2MWET               131500 non-null  float64
 8   T2M_MAX              131500 non-null  float64
 9   T2M_MIN              131500 non-null  float64
 10  T2M                  131500 non-null  float64
 11  QV2M                 131500 non-null  float64
 12  RH2M                 131500 non-null  float64
 13  PRECTOTCORR          131500 non-null  float64
 14  PS                   131500 non-null  float64
 15  WS2M             [...]<jupyter_text>Transformando o codigo em inteiro novamente.<jupyter_code>dataset['codigo_ibge']=list(map(int,dataset['codigo_ibge']))

#df.loc[df['codigo_ibge']==codigo_saida[0]]<jupyter_output><empty_output><jupyter_text>Vamos começar transformando os dados de data em 'datetime' para melhor agrupar em semanas, meses ou anos.<jupyter_code>def t_data_day(data):
    data=str(data)
    data=datetime.strptime(data,"%Y%m%d")
    return data.day

def t_data_month(data):
    data=str(data)
    data=datetime.strptime(data,"%Y%m%d")
    return data.month

def t_data_year(data):
    data=str(data)
    data=datetime.strptime(data,"%Y%m%d")
    return data.year
    #return data.day, data.month, data.year
dataset['day']=list(map(t_data_day, dataset['data']))
dataset['month']=list(map(t_data_month, dataset['data']))
dataset['year']=list(map(t_data_year, dataset['data']))
dataset.head()<jupyter_output><empty_output><jupyter_text>Uma feature importante é o valor da produção do ano passado, podemos tentar prever a produção de 2013 e criar uma feature depois.<jupyter_code>dataset=dataset.drop(dataset.loc[dataset['year']==2003].index).reset_index(drop=True)<jupyter_output><empty_output><jupyter_text>Podemo implementar um sistema para previsões baseado na média dos valores mensais.<jupyter_code>dataset=dataset.drop(columns=['data','latitude','longitude','day'])<jupyter_output><empty_output><jupyter_text>Para cada codigo postal iremos fazer um subgrupo para cada ano e agrupar os meses pela média. Depois concatenamos e criamos o novo dataset.<jupyter_code>codigos=dataset['codigo_ibge'].unique()
anos=dataset['year'].unique()

datanew=pd.DataFrame(columns=dataset.keys())

for i in codigos:
    for j in anos:
        aux = dataset.loc[dataset['codigo_ibge']==i].loc[dataset['year']==j].groupby(by='month').agg('mean').reset_index()
        datanew=pd.concat([datanew,aux])
    
datanew=datanew.reset_index(drop=True)
datanew.head()<jupyter_output><empty_output><jupyter_text>Precisamos colocar os dados dos meses em uma unica linha para alimentar a entrada do modelo.  Criando a lista de indices:<jupyter_code>col=list(datanew.keys())
col.remove('year')
col.remove('codigo_ibge')
#removendo os dados que não serão escalados
lista_indices=[]

lista_indices.append('codigo_ibge')

for i in range(12):

    
    for j in col:
        
        aux=j+'_'+str(i+1)
        lista_indices.append(aux)
        
lista_indices.append('month')
lista_indices.append('year')
lista_indices<jupyter_output><empty_output><jupyter_text>Iremos criar um dataset menor para cada mês, mudar o nome dos indices para o indice_mes e depois juntar todos em um dataset com todos os indices ordenados por mês.<jupyter_code>df_m=datanew[col].loc[datanew['month']==1].rename(columns=dict(zip(col[0:34],lista_indices[1:35]))).drop(columns='month')

a=35
b=69
for i in range(11):
        
    df_m2=datanew[col].loc[datanew['month']==i+2].rename(columns=dict(zip(col[0:34],lista_indices[a:b]))).drop(columns='month')
    a=b
    b=b+34
    df_m=pd.concat([df_m.reset_index(drop=True),df_m2.reset_index(drop=True)], axis=1)
    
df_m<jupyter_output><empty_output><jupyter_text>Reinserindo ano e codigo do ibge:<jupyter_code>df_m['codigo_ibge']=datanew['codigo_ibge'].loc[datanew['month']==1].reset_index(drop=True)
df_m['year']=datanew['year'].loc[datanew['month']==1].reset_index(drop=True)
df_m.head()
X_train=df_m.loc[df_m['year']<2018]
X_test=df_m.loc[df_m['year']>2017]<jupyter_output><empty_output><jupyter_text>Scalando os dados:<jupyter_code>colunas_=list(X_train.keys())

colunas_.remove('year')
colunas_.remove('codigo_ibge')
#removendo os dados que não serão escalados
len(colunas_)
X_train[colunas_]
scaler=StandardScaler()


X_train_scaled=scaler.fit_transform(X_train[colunas_])
X_train_scaled=pd.DataFrame(X_train_scaled, columns=colunas_)


X_test_scaled=scaler.transform(X_test[colunas_])
X_test_scaled=pd.DataFrame(X_test_scaled, columns=colunas_)<jupyter_output><empty_output><jupyter_text>Precisamos reinserir o codigo_ibge e ano e resetar o indice.<jupyter_code>X_train_scaled[['codigo_ibge','year']]=X_train[['codigo_ibge','year']].reset_index(drop=True)
X_test_scaled[['codigo_ibge','year']]=X_test[['codigo_ibge','year']].reset_index(drop=True)
X_train_scaled
#k-fold para achar melhor valor de alpha
model = LassoCV(cv=10, random_state=0, max_iter=10000)


df_out=pd.DataFrame(columns=['codigo_ibge','2018','2019','2020'])

for i in codigo_saida:
    
    X_train_menor=X_train_scaled.loc[X_train_scaled['codigo_ibge']==i].drop(columns=['codigo_ibge','year'])
    Y_train_menor=Y_train[Y_train['codigo_ibge']==i].drop(columns='codigo_ibge').T
    
    model.fit(X_train_menor, Y_train_menor)
    
    lasso_t= Lasso(alpha=model.alpha_, max_iter= 10000).fit(X_train_menor,Y_train_menor)
    
    print(f'\n Alpha usado: {model.alpha_}')
    print('Features non-zero para {}: {}'.format(i, np.sum(lasso_t.coef_ != 0)))
    print('Features com valores non-zero (ordenados pela magnitude absoluta):')

    for e in sorted (list(zip(list(X_train), lasso_t.coef_)), key = lambda e: -abs(e[1])):
        if e[1] != 0:
            print('\t{}, {:.3f}'.format(e[0], e[1]))
    
    
    X_test_menor=X_test_scaled.loc[X_test_scaled['codigo_ibge']==i].drop(columns=['codigo_ibge','year'])
   
    predicoes=lasso_t.predict(X_test_menor)

    data_saida={'codigo_ibge':i, '2018':predicoes[0], '2019':predicoes[1], '2020':predicoes[2]}
    
    data_saida=pd.DataFrame([data_saida])
    
    df_out=pd.concat([df_out,data_saida])
df_out=df_out.reset_index(drop=True)
df_out
df_out.to_csv('submission.csv',index=False)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13102625298329357, 'fraction_numerical': 0.04737470167064439, 'mean_word_length': 5.330060422960725, 'pattern_counts': {'":': 0, '<': 54, '<?xml version=': 0, '>': 54, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '13', 'dir': 'jupyter-structured-clean-dedup', 'id': '229876', 'license': 'MIT', 'n_tokens_mistral': 3437, 'n_tokens_neox': 3169, 'n_words': 529, 'path': 'notebook_v2.ipynb', 'repo_name': 'nevesisaac/hacka-soja', 'size': '8380'}