Traindoo

traindoo

The AI revolution was decades in the making. It was a field filled with excitement, yet often punctuated by disappointments and “ .” But recently, something shifted. Large Language Models (LLMs) like ChatGPT, Claude, and Bard catapulted AI from laboratory curiosity to the . AI winters mainstream This shift wasn't solely a triumph of AI but also a victory over the intricacies of large and messy data. As the saying goes, “garbage in, garbage out.” New tools are emerging that focus on improving the underlying data, therefore improving LLMs. The Double Challenge of LLMs The term "Large Language Models" holds within it two great challenges. First, the sheer volume of data. We're talking upwards of a (a million gigabytes) of data for GPT-4, encompassing millions of books, blogs, social media posts, video transcripts, and more. This colossal scale offers vast potential but also poses significant logistical considerations. petabyte Second, the complexity of natural language. Context-dependent, ambiguous, and diverse, language data is a wild beast that even the best algorithms struggle to tame. It’s impossible to accurately label all this data, which inevitably means that even state-of-the-art LLMs are trained on tons of incorrectly-labeled data. In facing these challenges, new data-centric tools and methodologies emerged, enabling a true leap in what AI is capable of. Solutions like Cleanlab and others began to offer ways to collect diverse data, automate quality control, and process language into a form suitable for AI models. These tools did not merely offer incremental improvements; they fundamentally reshaped the approach to AI data handling. They transformed the task of handling large-scale language data from a manual, error-prone process into an automated, precise one, democratizing the field and enabling advancements at an unprecedented pace. Why Data-Centric AI is Needed (With a Python Demo) In AI, real-world datasets contain . These imperfections significantly hamper training and evaluation. Data-centric AI emphasizes improving the quality of the dataset itself. annotation errors ranging from 7-50% OpenAI's , for instance, illustrates this emphasis: “We prioritized filtering out all of the bad data over leaving in all of the good data. This is because we can always fine-tune our model with more data later to teach it new things, but it’s much harder to make the model forget something that it has already learned.” strategy An approach of manually filtering data, however, is time-consuming and expensive. The is an open-source framework popular for practicing data-centric AI today. It allows you to run data quality algorithms on your trained ML model's outputs to detect common dataset issues like label errors, outliers, drift, and more. Cleanlab package With just a few lines of code, you can automatically find and identify problems in various types of data, such as image, text, tabular, and audio. By using the Cleanlab package, you can decide how to improve your dataset and model, re-train your ML model, and see its performance improve without any changes to your existing code. Cleanlab Studio, on the other hand, is more than just an extension of the Cleanlab package; it's a no-code platform designed to find and fix problems in real-world datasets. It doesn't just stop at detecting issues but goes further in handling data curation and correction, and even automates almost all the hard parts of turning raw data into reliable ML or Analytics. Let’s use the Cleanlab package to demonstrate the power of data-centric AI. 1. Preparing data and fine-tuning We start with the . Ensure you have the and sets loaded. In this demo, we’ll fine-tune the Davinci LLM for 3-class classification, first without Cleanlab, and then see how we can improve accuracy with data-centricity. We can run a simple bash command to train a model. Stanford Politeness Dataset train test !openai api fine_tunes.create -t "train_prepared.jsonl" -v "test_prepared.jsonl" --compute_classification_metrics --classification_n_classes 3 -m davinci --suffix "baseline" When that’s done, we can query a endpoint to see the test accuracy. fine_tunes.results !openai api fine_tunes.results -i ft-9800F2gcVNzyMdTLKcMqAtJ5 > baseline.csv `df = pd.read_csv('baseline.csv') baseline_acc = df.iloc[-1]['classification/accuracy']` We get a result of 63% accuracy. Let’s see if we can improve this. 2. Obtain Predicted Class Probabilities Now, let’s use OpenAI's API to compute embeddings and fit a logistic regression model to obtain out-of-sample predicted class probabilities. # Get embeddings from OpenAI. from openai.embeddings_utils import get_embedding embedding_model = "text-similarity-davinci-001" train["embedding"] = train.prompt.apply(lambda x: get_embedding(x, engine=embedding_model)) embeddings = train["embedding"].values # Get out-of-sample predicted class probabilities via cross-validation. from sklearn.linear_model import LogisticRegression model = LogisticRegression()  labels = train["completion"].values  pred_probs = cross_val_predict(estimator=model, X=embeddings, y=labels,                           cv=10, method="predict_proba") With just one line of code, Cleanlab estimates which examples have label issues in our training dataset. from cleanlab.filter import find_label_issues Now we can get indices of examples estimated to have label issues: issue_idx = find_label_issues(labels, pred_probs, return_indices_ranked_by='self_confidence')  # sort indices by likelihood of label error 3. Filter Label Issues and Re-Train Now, we’ve automatically extracted the indices of potentially mislabeled examples, so we can remove them and train a new classifier. # Remove the label errors train_cl = train.drop(issue_idx).reset_index(drop=True) format_data(train_cl, "train_cl.jsonl") Now let’s train a more robust classifier with better data. !openai api fine_tunes.create -t "train_cl_prepared.jsonl" -v "test_prepared.jsonl" --compute_classification_metrics --classification_n_classes 3 -m davinci --suffix "dropped" # Evaluate model on test data !openai api fine_tunes.results -i ft-InhTRQGu11gIDlVJUt0LYbEx > cleanlab.csv df = pd.read_csv('cleanlab.csv') dropped_acc = df.iloc[-1]['classification/accuracy'] We get an accuracy of over 66%, improving a state-of-the-art fine-tunable model (GPT-3, as you can’t fine-tune GPT-4), merely by automatically improving the dataset, without any change to the model. With Cleanlab Studio, it’s also possible to automatically fix the incorrect labels instead of just removing them outright, improving accuracy even further. A by Cleanlab shows that this takes accuracy up to 77%. guide Takeaways Using data-centric tools like Cleanlab, you can efficiently find and fix data and label issues, leading to significant improvements in the performance of LLMs like Davinci. This approach does not alter the model architecture or hyperparameters and focuses only on enhancing the quality of the training data. The approach outlined in this guide could be the key to unlocking even greater accuracy and robustness in AI models, even with future advanced LLMs like GPT-5.

How to Make Any LLM More Accurate with Just a Few Lines of Code

মাত্র কয়েকটি লাইনের কোড দিয়ে যেকোনো এলএলএমকে আরও নির্ভুল কীভাবে করা যায়

So machen Sie jedes LLM mit nur wenigen Codezeilen genauer

Cómo hacer que cualquier LLM sea más preciso en solo unas pocas líneas de código

Comment rendre n'importe quel LLM plus précis en quelques lignes de code

कोड की कुछ पंक्तियों में किसी भी एलएलएम को और अधिक सटीक कैसे बनाएं

わずか数行のコードで LLM の精度を高める方法

단 몇 줄의 코드로 LLM을 더욱 정확하게 만드는 방법

Como tornar qualquer LLM mais preciso em apenas algumas linhas de código

Sadece Birkaç Satır Kodla Herhangi Bir LLM Nasıl Daha Doğru Hale Getirilir?

Cách làm cho bất kỳ LLM nào chính xác hơn chỉ bằng một vài dòng mã

如何仅用几行代码就可以使法学硕士更加准确

Feature Selection in python is the process where you automatically or manually select the features in the dataset that contribute most to your prediction variable or output in which you are interested. One major reason is that machine learning follows the rule of “garbage in garbage out” and that is why you need to be very concerned about the features that are being fed to the model. Keep in mind that not all features presented in your dataset are important to give you the best model performance. Top 4 Reasons to Apply Feature Selection in Python: It improves the accuracy of a model if the right subset is chosen. It reduces overfitting. It enables the machine learning algorithm to train faster. It reduces the complexity of a model and makes it easier to interpret. “I prepared a model by selecting all the features and I got an accuracy of around 65% which is not good for a predictive model and after doing some feature selection and feature engineering without doing any logical changes in my model code my accuracy jumped to 81% which is quite impressive”- By . Raheel Shaikh In this article, you will learn how to automatically select important features by using an open-source python package called featurewiz. What is Featurewiz? Featurewiz is a new open-source python package for automatically creating and selecting important features in your dataset that will create the best model with higher performance. It also uses advanced feature engineering strategies to create new features before selecting the best set of features with a single line of code. Note: Featurewiz can automatically detect if the problem is regression or classification. How does it work? Featurewiz uses the SULOV algorithm and Recursive XGBoost to reduce features to select the best features for the model. SULOV means Searching for Uncorrelated List of Variables. The algorithm works in the following steps. (a) SULOV First step: find all the pairs of highly correlated variables exceeding a correlation threshold (say absolute(0.8)). Second step: find their Mutual Information Score to the target variable. Mutual Information Score is a non-parametric scoring method. So it's suitable for all kinds of variables and target. Third step: take each pair of correlated variables, then knock off the one with the lower Mutual Information Score. Final step: Collect the ones with the highest Information scores and least correlation with each other. After selecting the features with less correlation and high mutual information score, the Recursive XGBoost is used to find the best features among the remaining features. Here is how it works. (b) Recursive XGBoost First step: Select all features in the dataset and split the dataset into train and valid sets. Second step: Find top X features on train using valid for early stopping (to prevent overfitting). Third step: Take the next set of features and find top X. Final step: Repeat this 5 times and finally combine all selected features and de-duplicate them. Installation The package requires xgboost, NumPy, pandas and matplotlib. In addition, tIt should run on most Python 3. You can install Featurewiz using PyPI. pip install featurewiz How to Use Featurewiz for Feature Selection in Python We will use the Mobile Price dataset to find the best features that can help to get good accuracy when predicting the price range. 0 (low cost) 1 (medium cost) 2 (high cost) 4 (very high cost) You can download the dataset . here Import python packages. pandas pd numpy np seaborn sns sklearn.model_selection train_test_split sklearn.preprocessing StandardScaler sklearn.ensemble RandomForestClassifier sklearn.linear_model LogisticRegression sklearn.metrics accuracy_score featurewiz featurewiz
np.random.seed( ) # import packages import as import as import as from import from import from import from import from import from import 1234 Load the Mobile Price dataset. data = pd.read_csv( )
 
data.shape '../data/train.csv' (2000, 21) The dataset contains 21 columns(20 features and 1 target) and luckily this dataset has no missing values. Split the data into independent features and target. X = data.drop([ ],axis= )
 
y = data.price_range.values 'price_range' 1 Then Standardize the features by using StandardScaler from scikit-learn. X_scaled =  StandardScaler().fit_transform(X) Split the data into train and validate sets. 20% of the data will be used for validation. X_train, X_valid, y_train, y_valid = train_test_split(X_scaled,y,test_size = ,stratify=y, random_state= ) 0.2 1 Create and train the on the train set. RandoForestclassifier classifier = RandomForestClassifier()
 
classifier.fit(X_train,y_train) Make a prediction on the validation set and then check model performance. preds = classifier.predict(X_valid) accuracy_score(preds,y_valid) # make prediction # check performance 0.88 The model accuracy is when we use all 20 features available in the dataset. 88% Now you can use Featurewiz to automatically select the best set of features that will give the best model performance. target = features, train = featurewiz(data, target, corr_limit= , verbose= , sep= ,
header= ,test_data= , feature_engg= , category_encoders= ) # automatic feature selection by using featurewiz package 'price_range' 0.7 2 "," 0 "" "" "" On the Featurewiz instance, we have added the dataset and the name of the target variable. You can also change the correlation limit by using corr_limit (by default is 7). During the selection process, it will show the following series of output. Skipping feature engineering since no feature_engg input...
Skipping category encoding since no category encoders specified input...
Loading train data...
Shape of your Data Set loaded: ( , )
Loading test data...
    Filename an empty string file able to be loaded Classifying variables data set... Predictors classified...
        No variables removed since no ID low-information variables found data set
No GPU active on this device
    Running XGBoost using CPU parameters
Removing columns further processing since ID low information variables
    columns removed: []
    After removing redundant variables further processing, features left = Searching highly correlated variables variables using SULOV method No highly correlated variables data set to remove. All selected...
    Adding categorical variables to reduced numeric variables  of Current number of predictors = Finding Important Features using Boosted Trees algorithm...
        using variables...
        using variables...
        using variables...
        using variables...
        using variables...
Selected important features your dataset
    Time taken ( seconds) = Returning list of important features dataframe. in 2000 21 is or not ############## C L A S S I F Y I N G  V A R I A B L E S  #################### in 20 or in 0 from or from 20 #### Single_Label Multi_Classification Feature Selection Started #### for from 20 #####  SULOV : Searching for Uncorrelated List Of Variables (takes time...) ############ in 0 20 ############## F E A T U R E   S E L E C T I O N  #################### 20 20 16 12 8 4 16 from in 19 16 and As you can see, Featurewiz selects 16 important features from the dataset. The Featurewiz instance returns two objects Features - a list of selected features One dataframe - This dataframe contains only selected features and the target variable. Now you can train the RandomForestClassifier again with selected features and see if the model performance will improve. Let see the list of selected features. print(features) ['ram', 'battery_power', 'px_height', 'px_width', 'touch_screen', 'mobile_wt', 'int_memory', 'three_g', 'sc_h', 'four_g', 'sc_w', 'n_cores', 'fc', 'pc', 'talk_time', 'wifi'] Split the one dataframe into selected features and the target. X_new = train.drop([ ],axis= )
 
y = train.price_range.values #split data into feature and target 'price_range' 1 Then, Standardize the selected features by using StandardScaler from scikit-learn. X_scaled =  StandardScaler().fit_transform(X_new) # preprocessing the features Split the data into train and validate sets. 20% of the data will be used for validation. X_train, X_valid, y_train, y_valid = train_test_split(X_scaled,y,test_size = ,stratify=y, random_state= ) #split data into train and validate 0.2 1 Create and train the RandoForestclassifier on the train set again. classifier = RandomForestClassifier()
 
classifier.fit(X_train,y_train) # create and train classifier Make a prediction on the validation set and then check model performance. preds = classifier.predict(X_valid) accuracy_score(preds,y_valid) # make prediction # check performance 0.905 The model accuracy has increased from to when we use the best-selected features (16 out of 20  features) from the dataset. 88% 90.5% Final Thoughts on Feature Selection in Python In this article, you have learned how you can automatically select important features by using the Featurewiz package. You can also use Featurewiz on any Multi-Class or Multi-Label Dataset. So you can have as many target labels as you want. There are more options available on the Featurewiz package. I recommend you read them here. If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! You can also find me on Twitter . @Davis_McDavid And you can read more articles like this . here Want to keep up to date with all the latest in python? in the footer below. Subscribe to our newsletter

Automatic Feature Selection in Python: An Essential Guide

Selección automática de características en Python: una guía esencial

Sentiment analysis is a technique used to determine if data is , , or . Natural Language Processing (NLP) positive negative neutral Sentiment analysis is fundamental, as it helps to understand the emotional tones within language. This, in turn, helps to automatically sort the opinions behind reviews, social media discussions, etc., allowing you to make faster, more accurate decisions. Although sentiment analysis has become extremely popular in recent times, work on it has been progressing since the early 2000s. Traditional machine learning methods such as Naive Bayesian, Logistic Regression, and Support Vector Machines (SVMs) are widely used for large-scale sentiment analysis because they scale well. Deep learning (DL) techniques have now been proven to provide better accuracy for various NLP tasks, including sentiment analysis; however, they tend to be slower and more expensive to learn and use. In this story, I want to offer a little-known alternative that combines speed and quality. For conclusions and assessments of the proposed method, I need a baseline model. I chose the time-tested and popular BERT. Getting the Data Social media is a source that produces a massive amount of data on an unprecedented scale. The dataset I will be using for this story is . Coronavirus tweets NLP As I can see, there is not so much data for the model, and at first glance, it seems that one cannot do without a pre-trained model. Due to the small number of samples for training, I reduce the number of classes to 3 by combining them. Baseline BERT Model Let’s use TensorFlow Hub. TensorFlow Hub is a repository of trained machine learning models ready for fine-tuning and deployable anywhere. You can use trained models like BERT and Faster R-CNN with just a few lines of code. !pip install tensorflow_hub
!pip install tensorflow_text Smaller BERT model. small_bert/bert_en_uncased_L-4_H-512_A-8 — This is one of the smaller BERT models referenced in . The smaller BERT models are intended for environments with restricted computational resources. They can be fine-tuned in the same manner as the original BERT models. However, they are most effective in the context of knowledge distillation, where a larger and more accurate teacher produces the fine-tuning labels. Well-Read Students Learn Better: On the Importance of Pre-training Compact Models Text preprocessing for BERT. This model uses a vocabulary for English extracted from Wikipedia and BooksCorpus. Text inputs have been normalized the “uncased” way, meaning that the text has been lower-cased before tokenization into word pieces, and any accent markers have been stripped. bert_en_uncased_preprocess — tfhub_handle_encoder = \ tfhub_handle_preprocess = \ "https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1" "https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3" I will not make the selection of parameters and optimization in order not to complicate the code. All the same, this is the baseline model, not SOTA. def build_classifier_model():
    
    text_input = tf.keras.layers.Input(
        shape=(), dtype=tf.string, name= )
    
    preprocessing_layer = hub.KerasLayer(
        tfhub_handle_preprocess, name= )
    
    encoder_inputs = preprocessing_layer(text_input)
    encoder = hub.KerasLayer(
        tfhub_handle_encoder, trainable=True, name= )
    
    outputs = encoder(encoder_inputs)
    net = outputs[ ]
    net = tf.keras.layers.Dropout( )(net)
    net = tf.keras.layers.Dense( , activation= , name= )(net)
    model = tf.keras.Model(text_input, net)
    
    loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
    metric = tf.metrics.CategoricalAccuracy( )
    optimizer = Adam(
        learning_rate= , epsilon= , decay= , clipnorm= )
    model.compile(
        optimizer=optimizer, loss=loss, metrics=metric)
    model.summary() model 'text' 'preprocessing' 'BERT_encoder' 'pooled_output' 0.1 3 'softmax' 'classifier' 'accuracy' 5e-05 1e-08 0.01 1.0 return I have created a model with just under 30M parameters. I allocated 30 percent of the data for model validation. train train, valid = train_test_split(
    df_train,
    train_size= ,
    random_state= ,
    stratify=df_train[ ])
y_train, X_train = \
    train[ ], train.drop([ ], axis= )
y_valid, X_valid = \
    valid[ ], valid.drop([ ], axis= )
y_train_c = tf.keras.utils.to_categorical(
    y_train.astype( ).cat.codes.values, num_classes= )
y_valid_c = tf.keras.utils.to_categorical(
    y_valid.astype( ).cat.codes.values, num_classes= ) 0.7 0 'Sentiment' 'Sentiment' 'Sentiment' 1 'Sentiment' 'Sentiment' 1 'category' 3 'category' 3 The number of epochs was chosen intuitively and did not require justification :) history = classifier_model.fit(
    x=X_train[ ].values,
    y=y_train_c,
    validation_data=(X_valid[ ].values, y_valid_c),
    epochs= ) 'Tweet' 'Tweet' 5 BERT Accuracy: 0.833859920501709 Confusion Matrix: Classification Report: Here I have the baseline model. Obviously, I can improve this model further. But let’s leave this task as your homework. CatBoost Model is a high-performance, open-source library for gradient boosting on decision trees. From release 0.19.1, it supports text features for classification on GPU out-of-the-box. CatBoost The main advantage is that CatBoost can include categorical functions and text functions in your data without additional preprocessing. For those who value inference speed — CatBoost predictions are 20 to 40 times faster than other open-source gradient boosting libraries, making CatBoost useful for latency-critical tasks. !pip install catboost I will not select the optimal parameters; let that be your other homework. Let’s write a function to initialize and train the model. def fit_model(train_pool, test_pool, **kwargs):
    model = CatBoostClassifier(
        task_type= ,
        iterations= ,
        eval_metric= ,
        od_type= ,
        od_wait= ,
        **kwargs
    ) model.fit(
        train_pool,
        eval_set=test_pool,
        verbose= ,
        plot=True,
        use_best_model=True) 'GPU' 5000 'Accuracy' 'Iter' 500 return 100 When working with CatBoost, I recommend using a . The Pool is a convenience wrapper combining features, labels, and further metadata like categorical and text features. Pool train_pool = Pool(
    data=X_train,
    label=y_train,
    text_features=[ ]
)
valid_pool = Pool(
    data=X_valid, 
    label=y_valid,
    text_features=[ ]
) 'Tweet' 'Tweet' text_features — A one-dimensional array of text columns indices (specified as integers) or names (specified as strings). Use only if the data parameter is a two-dimensional feature matrix (has one of the following types: list, numpy.ndarray, pandas.DataFrame, pandas.Series). If any elements in this array are specified as names instead of indices, names for all columns must be provided. To do this, either use the feature_names parameter of this constructor to explicitly specify them or pass a pandas.DataFrame with column names specified in the data parameter. Supported : training parameters — Tokenizers are used to preprocess Text type feature columns before creating the dictionary. tokenizers Dictionaries used to preprocess Text type feature columns. dictionaries — Feature calcers used to calculate new features based on preprocessed Text type feature columns. feature_calcers — I set all the parameters intuitively; tuning them will be your homework again. model = fit_model(
    train_pool, valid_pool,
    learning_rate= ,
    tokenizers=[
        { : , : , : , :[ , , ], : }      
    ],
    dictionaries = [
        { : , : }
    ],
    feature_calcers = [ ]
) 0.35 'tokenizer_id' 'Sense' 'separator_type' 'BySense' 'lowercasing' 'True' 'token_types' 'Word' 'Number' 'SentenceBreak' 'sub_tokens_policy' 'SeveralTokens' 'dictionary_id' 'Word' 'max_dictionary_size' '50000' 'BoW:top_tokens_count=10000' Accuracy: Loss: CatBoost model accuracy: 0.8299104791995787 Confusion Matrix: Classification Report: The result is very close to what the baseline BERT model has shown. Because I have very little data for training, and the model was taught from scratch, the result is, in my opinion, impressive. Bonus I got two models with very similar results. Can this give us anything else useful? Both models have little in common at their core, which means that their combination should give a synergistic effect. The easiest way to test this conclusion is to average the result and see what happens. y_proba_avg = np.argmax((y_proba_cb + y_proba_bert)/ , axis= ) 2 1 The gain is impressive. Average accuracy: 0.855713533438652 Confusion Matrix: Classification Report: Summary In this story, I: created a baseline model using BERT; created a model with CatBoost using built-in text capabilities; looked at what happens if average the result from both models. In my opinion, complex and slow SOTAs can be avoided in most cases, especially if speed is a critical need. CatBoost provides great sentiment analysis capabilities right out of the box. For competition lovers like , , etc., CatBoost can provide a good model both as a baseline solution and as a part of an ensemble of models. Kaggle DrivenData The code from the story can be viewed . here

Unconventional Sentiment Analysis: BERT vs. Catboost

In case you missed it, I using a from . Then I built a to serve the model’s predictions. That’s nice and all, but… how is my model? built a neural network to predict loan risk public dataset LendingClub public API good Today I’m going to put it to the test, pitting it against the risk models of the very institution who issued those loans. That’s right, LendingClub included their own calculated loan grades (and sub-grades) in the dataset, so all the pieces are in place for the most thrilling risk modeling smackdown of this century (or at least this week). May the best algorithm win! joblib

prev_notebook_folder = loans = joblib.load(prev_notebook_folder + )
loans.shape import "../input/building-a-neural-network-to-predict-loan-risk/" "loans_for_eval.joblib" (1110171, 70) loans.head() ┌────┬────────────┬────────────┬─────────────┬─────────────────┬─────────────┬─────────────────────┬────────┬──────────────┬───────────────────┬─────────────────┬──────┬────────────┬──────────────────┬────────────────────┬─────────────────┬─────────────────────────────┬─────────────────────┬───────────┬────────┬────────────┬─────────────────┐
│    │ loan_amnt  │   term     │ emp_length  │ home_ownership  │ annual_inc  │      purpose        │  dti   │ delinq_2yrs  │ cr_hist_age_mths  │ fico_range_low  │ ...  │ tax_liens  │ tot_hi_cred_lim  │ total_bal_ex_mort  │ total_bc_limit  │ total_il_high_credit_limit  │ fraction_recovered  │ issue_d   │ grade  │ sub_grade  │ expected_return │
├────┼────────────┼────────────┼─────────────┼─────────────────┼─────────────┼─────────────────────┼────────┼──────────────┼───────────────────┼─────────────────┼──────┼────────────┼──────────────────┼────────────────────┼─────────────────┼─────────────────────────────┼─────────────────────┼───────────┼────────┼────────────┼─────────────────┤
│ 0  │    3600.0  │ 36 months  │ 10+ years   │ MORTGAGE        │    55000.0  │ debt_consolidation  │  5.91  │         0.0  │            148.0  │          675.0  │ ...  │       0.0  │        178050.0  │            7746.0  │         2400.0  │                    13734.0  │                1.0  │ Dec-2015  │ C      │ C4         │         4429.08 │
│ 1  │   24700.0  │ 36 months  │ 10+ years   │ MORTGAGE        │    65000.0  │ small_business      │ 16.06  │         1.0  │            192.0  │          715.0  │ ...  │       0.0  │        314017.0  │           39475.0  │        79300.0  │                    24667.0  │                1.0  │ Dec-2015  │ C      │ C1         │        29530.08 │
│ 2  │   20000.0  │ 60 months  │ 10+ years   │ MORTGAGE        │    63000.0  │ home_improvement    │ 10.78  │         0.0  │            184.0  │          695.0  │ ...  │       0.0  │        218418.0  │           18696.0  │         6200.0  │                    14877.0  │                1.0  │ Dec-2015  │ B      │ B4         │        25959.60 │
│ 4  │   10400.0  │ 60 months  │ 3 years     │ MORTGAGE        │   104433.0  │ major_purchase      │ 25.37  │         1.0  │            210.0  │          695.0  │ ...  │       0.0  │        439570.0  │           95768.0  │        20300.0  │                    88097.0  │                1.0  │ Dec-2015  │ F      │ F1         │        17394.60 │
│ 5  │   11950.0  │ 36 months  │ 4 years     │ RENT            │    34000.0  │ debt_consolidation  │ 10.20  │         0.0  │            338.0  │          690.0  │ ...  │       0.0  │         16900.0  │           12798.0  │         9400.0  │                     4000.0  │                1.0  │ Dec-2015  │ C      │ C3         │        14586.48 │
└────┴────────────┴────────────┴─────────────┴─────────────────┴─────────────┴─────────────────────┴────────┴──────────────┴───────────────────┴─────────────────┴──────┴────────────┴──────────────────┴────────────────────┴─────────────────┴─────────────────────────────┴─────────────────────┴───────────┴────────┴────────────┴─────────────────┘
5 rows × 70 columns This post was adapted from a Jupyter Notebook, by the way, so if you’d like to follow along in your own notebook, go ahead and fork mine or ! Kaggle GitHub Ground rules This is going to be a clean fight—my model won’t use any data LendingClub wouldn’t have access to at the point they calculate a loan’s grade (including the grade itself). I’m going to sort the dataset chronologically (using the column, the month and year the loan was issued) and split it into two parts. The first 80% I’ll use for training my competition model, and I’ll compare performance on the last 20%. issue_d sklearn.model_selection train_test_split

loans[ ] = loans[ ].astype( )
loans.sort_values( , axis= , inplace= , kind= )

train, test = train_test_split(loans, test_size= , shuffle= )
train, test = train.copy(), test.copy()
print( ) from import "date" "issue_d" "datetime64[ns]" "date" "index" True "mergesort" 0.2 False f"The test set contains loans." {len(test):,} The test set contains 222,035 loans. At the earlier end of the test set my model may have a slight informational advantage, having been trained on a few loans that may not have closed yet at the point LendingClub was grading those ones. On the other hand, LendingClub may have a slight informational advantage on the later end of the test set, since they would have known the outcomes of some loans on the earlier end of the test set by that time. I have to give credit to Michael Wurm, by the way, for of comparing my model’s performance to LendingClub’s loan grades, but my approach is pretty different. I’m not trying to simulate the performance of an investment portfolio; I’m just evaluating how well my predictions of simple risk compare. the idea Test metric The test: who can pick the best set of grade A loans, judged on the basis of the independent variable from , the fraction of an expected loan return that a prospective borrower will pay back (which I engineered as ). my last notebook fraction_recovered LendingClub will take the plate first. I’ll gather all their grade A loans from the test set, count them, and calculate their average . That average will be the metric my model has to beat. fraction_recovered Then I’ll train my model on the training set using the same pipeline and parameters I settled on in . Once it’s trained, I’ll use it to make predictions on the test set, then gather the number of top predictions equal to the number of LendingClub’s grade A loans. Finally, I’ll calculate the same average of on that subset, and we’ll have ourselves a winner! my last notebook fraction_recovered LendingClub's turn statistics mean

lc_grade_a = test[test[ ] == ]
print( )

print( )
print(round(mean(lc_grade_a[ ]), )) from import "grade" "A" f"LendingClub gave loans in the test set an A grade." {len(lc_grade_a):,} "\nAverage `fraction_recovered` on LendingClub's grade A loans:" "fraction_recovered" 5 LendingClub gave 38,779 loans in the test set an A grade.

Average `fraction_recovered` on LendingClub's grade A loans:
0.96021 That’s a pretty high percentage. I’m a bit nervous. My turn First, I’ll copy over my function from : run_pipeline my previous notebook sklearn.model_selection train_test_split sklearn_pandas DataFrameMapper sklearn.preprocessing OneHotEncoder, OrdinalEncoder, StandardScaler tensorflow.keras Sequential, Input tensorflow.keras.layers Dense, Dropout X = data.drop(columns=[ ])
    y = data[ ]
    X_train, X_valid, y_train, y_valid = (
        train_test_split(X, y, test_size= , random_state= ) validate (X, , y, )
    )

    transformer = DataFrameMapper(
        [
            (onehot_cols, OneHotEncoder(drop= )),
            (
                list(ordinal_cols.keys()),
                OrdinalEncoder(categories=list(ordinal_cols.values())),
            ),
        ],
        default=StandardScaler(),
    )

    X_train = transformer.fit_transform(X_train)
    X_valid = transformer.transform(X_valid) validate input_nodes = X_train.shape[ ]
    output_nodes = model = Sequential()
    model.add(Input((input_nodes,)))
    model.add(Dense( , activation= ))
    model.add(Dropout( , seed= ))
    model.add(Dense( , activation= ))
    model.add(Dropout( , seed= ))
    model.add(Dense( , activation= ))
    model.add(Dropout( , seed= ))
    model.add(Dense(output_nodes))
    model.compile(optimizer= , loss= )

    history = model.fit(
        X_train,
        y_train,
        batch_size=batch_size,
        epochs= ,
        validation_data=(X_valid, y_valid) validate ,
        verbose= ,
    ) history.history, model, transformer


onehot_cols = [ , , , ]
ordinal_cols = { : [ , , , , , , , , , , ,
    ]
} from import from import from import from import from import : def run_pipeline (
    data,
    onehot_cols,
    ordinal_cols,
    batch_size,
    validate=True,
) "fraction_recovered" "fraction_recovered" 0.2 0 if else None None "if_binary" if else None 1 1 64 "relu" 0.3 0 32 "relu" 0.3 1 16 "relu" 0.3 2 "adam" "mean_squared_logarithmic_error" 100 if else None 2 return "term" "application_type" "home_ownership" "purpose" "emp_length" "< 1 year" "1 year" "2 years" "3 years" "4 years" "5 years" "6 years" "7 years" "8 years" "9 years" "10+ years" Now for the moment of truth: _, model, transformer = run_pipeline(
    train.drop(columns=[ , , , , ]),
    onehot_cols,
    ordinal_cols,
    batch_size= ,
    validate= ,
) X_test = transformer.transform(
    test.drop(
        columns=[ , , , , , ,
        ]
    )
)
test[ ] = model.predict(X_test) test_sorted = test.sort_values( , axis= , ascending= )
ty_grade_a = test_sorted.iloc[ :len(lc_grade_a)] print( )
print(format(mean(ty_grade_a[ ]), )) # Train the model "issue_d" "date" "grade" "sub_grade" "expected_return" 128 False # Make predictions "fraction_recovered" "issue_d" "date" "grade" "sub_grade" "expected_return" "model_predictions" # Gather top predictions "model_predictions" "index" False 0 # Display results "\nAverage `fraction_recovered` on Ty's grade A loans:" "fraction_recovered" ".5f" Epoch 1/100
6939/6939 - 13s - loss: 0.0249
Epoch 2/100
6939/6939 - 13s - loss: 0.0204
Epoch 3/100
6939/6939 - 13s - loss: 0.0202
Epoch 4/100
6939/6939 - 13s - loss: 0.0202
Epoch 5/100
6939/6939 - 13s - loss: 0.0202
Epoch 6/100
6939/6939 - 14s - loss: 0.0201
Epoch 7/100
6939/6939 - 14s - loss: 0.0201
Epoch 8/100
6939/6939 - 14s - loss: 0.0201
Epoch 9/100
6939/6939 - 13s - loss: 0.0201
Epoch 10/100
6939/6939 - 12s - loss: 0.0201
Epoch 11/100
6939/6939 - 13s - loss: 0.0201
Epoch 12/100
6939/6939 - 13s - loss: 0.0201
Epoch 13/100
6939/6939 - 13s - loss: 0.0201
Epoch 14/100
6939/6939 - 13s - loss: 0.0201
Epoch 15/100
6939/6939 - 12s - loss: 0.0201
Epoch 16/100
6939/6939 - 12s - loss: 0.0201
Epoch 17/100
6939/6939 - 13s - loss: 0.0200
Epoch 18/100
6939/6939 - 13s - loss: 0.0200
Epoch 19/100
6939/6939 - 13s - loss: 0.0200
Epoch 20/100
6939/6939 - 14s - loss: 0.0200
Epoch 21/100
6939/6939 - 13s - loss: 0.0200
Epoch 22/100
6939/6939 - 13s - loss: 0.0200
Epoch 23/100
6939/6939 - 12s - loss: 0.0200
Epoch 24/100
6939/6939 - 12s - loss: 0.0200
Epoch 25/100
6939/6939 - 12s - loss: 0.0200
Epoch 26/100
6939/6939 - 13s - loss: 0.0200
Epoch 27/100
6939/6939 - 13s - loss: 0.0200
Epoch 28/100
6939/6939 - 13s - loss: 0.0200
Epoch 29/100
6939/6939 - 13s - loss: 0.0200
Epoch 30/100
6939/6939 - 13s - loss: 0.0200
Epoch 31/100
6939/6939 - 15s - loss: 0.0200
Epoch 32/100
6939/6939 - 13s - loss: 0.0200
Epoch 33/100
6939/6939 - 12s - loss: 0.0200
Epoch 34/100
6939/6939 - 13s - loss: 0.0200
Epoch 35/100
6939/6939 - 13s - loss: 0.0200
Epoch 36/100
6939/6939 - 13s - loss: 0.0200
Epoch 37/100
6939/6939 - 13s - loss: 0.0200
Epoch 38/100
6939/6939 - 13s - loss: 0.0200
Epoch 39/100
6939/6939 - 13s - loss: 0.0200
Epoch 40/100
6939/6939 - 13s - loss: 0.0200
Epoch 41/100
6939/6939 - 13s - loss: 0.0200
Epoch 42/100
6939/6939 - 13s - loss: 0.0200
Epoch 43/100
6939/6939 - 14s - loss: 0.0200
Epoch 44/100
6939/6939 - 13s - loss: 0.0200
Epoch 45/100
6939/6939 - 13s - loss: 0.0200
Epoch 46/100
6939/6939 - 13s - loss: 0.0200
Epoch 47/100
6939/6939 - 13s - loss: 0.0200
Epoch 48/100
6939/6939 - 13s - loss: 0.0200
Epoch 49/100
6939/6939 - 13s - loss: 0.0200
Epoch 50/100
6939/6939 - 13s - loss: 0.0200
Epoch 51/100
6939/6939 - 13s - loss: 0.0200
Epoch 52/100
6939/6939 - 13s - loss: 0.0200
Epoch 53/100
6939/6939 - 13s - loss: 0.0200
Epoch 54/100
6939/6939 - 14s - loss: 0.0200
Epoch 55/100
6939/6939 - 14s - loss: 0.0200
Epoch 56/100
6939/6939 - 13s - loss: 0.0200
Epoch 57/100
6939/6939 - 13s - loss: 0.0200
Epoch 58/100
6939/6939 - 13s - loss: 0.0200
Epoch 59/100
6939/6939 - 13s - loss: 0.0200
Epoch 60/100
6939/6939 - 13s - loss: 0.0200
Epoch 61/100
6939/6939 - 13s - loss: 0.0200
Epoch 62/100
6939/6939 - 13s - loss: 0.0200
Epoch 63/100
6939/6939 - 13s - loss: 0.0200
Epoch 64/100
6939/6939 - 13s - loss: 0.0200
Epoch 65/100
6939/6939 - 12s - loss: 0.0200
Epoch 66/100
6939/6939 - 13s - loss: 0.0200
Epoch 67/100
6939/6939 - 14s - loss: 0.0200
Epoch 68/100
6939/6939 - 13s - loss: 0.0200
Epoch 69/100
6939/6939 - 13s - loss: 0.0200
Epoch 70/100
6939/6939 - 13s - loss: 0.0200
Epoch 71/100
6939/6939 - 13s - loss: 0.0200
Epoch 72/100
6939/6939 - 13s - loss: 0.0200
Epoch 73/100
6939/6939 - 13s - loss: 0.0200
Epoch 74/100
6939/6939 - 13s - loss: 0.0200
Epoch 75/100
6939/6939 - 13s - loss: 0.0200
Epoch 76/100
6939/6939 - 13s - loss: 0.0200
Epoch 77/100
6939/6939 - 13s - loss: 0.0200
Epoch 78/100
6939/6939 - 13s - loss: 0.0200
Epoch 79/100
6939/6939 - 14s - loss: 0.0200
Epoch 80/100
6939/6939 - 13s - loss: 0.0200
Epoch 81/100
6939/6939 - 13s - loss: 0.0200
Epoch 82/100
6939/6939 - 13s - loss: 0.0200
Epoch 83/100
6939/6939 - 13s - loss: 0.0200
Epoch 84/100
6939/6939 - 12s - loss: 0.0200
Epoch 85/100
6939/6939 - 13s - loss: 0.0200
Epoch 86/100
6939/6939 - 13s - loss: 0.0200
Epoch 87/100
6939/6939 - 13s - loss: 0.0200
Epoch 88/100
6939/6939 - 13s - loss: 0.0200
Epoch 89/100
6939/6939 - 13s - loss: 0.0200
Epoch 90/100
6939/6939 - 13s - loss: 0.0200
Epoch 91/100
6939/6939 - 14s - loss: 0.0200
Epoch 92/100
6939/6939 - 13s - loss: 0.0200
Epoch 93/100
6939/6939 - 13s - loss: 0.0200
Epoch 94/100
6939/6939 - 13s - loss: 0.0200
Epoch 95/100
6939/6939 - 13s - loss: 0.0200
Epoch 96/100
6939/6939 - 13s - loss: 0.0200
Epoch 97/100
6939/6939 - 13s - loss: 0.0200
Epoch 98/100
6939/6939 - 13s - loss: 0.0200
Epoch 99/100
6939/6939 - 13s - loss: 0.0200
Epoch 100/100
6939/6939 - 13s - loss: 0.0200

Average `fraction_recovered` on Ty's grade A loans:
0.96166 Victory! Phew, that was a close one! My win might be too small to be statistically significant, but hey, it’s cool seeing that I can keep up with LendingClub’s best and brightest. What I’d really like to know now is what quantitative range of estimated risk each LendingClub grade and sub-grade corresponds to, but it looks like . Does anyone know if loans grades generally correspond to certain percentage ranges like letter grades in academic classes? If not, have any ideas for better benchmarks I could use to evaluate my model’s performance? Go ahead and chime in in the comments below. that’s proprietary Previously published at https://tymick.me/blog/loan-grading-showdown

Can I Grade Loans Better Than LendingClub?

Sentiment Classification for 2019 Lok Sabha Elections Using Text Based Classifiers 

Tensorflow Vs. Keras: Comparison by building a model for image classification

Table of Links Abstract and 1 Introduction 2 Related Work 2.1 Neural Codec Language Models and 2.2 Non-autoregressive Models 2.3 Diffusion Models and 2.4 Zero-shot Voice Cloning 3 Hierspeech++ and 3.1 Speech Representations 3.2 Hierarchical Speech Synthesizer 3.3 Text-to-Vec 3.4 Speech Super-resolution 3.5 Model Architecture 4 Speech Synthesis Tasks 4.1 Voice Conversion and 4.2 Text-to-Speech 4.3 Style Prompt Replication 5 Experiment and Result, and Dataset 5.2 Preprocessing and 5.3 Training 5.4 Evaluation Metrics 5.5 Ablation Study 5.6 Zero-shot Voice Conversion 5.7 High-diversity but High-fidelity Speech Synthesis 5.8 Zero-shot Text-to-Speech 5.9 Zero-shot Text-to-Speech with 1s Prompt 5.10 Speech Super-resolution 5.11 Additional Experiments with Other Baselines 6 Limitation and Quick Fix 7 Conclusion, Acknowledgement and References 5 EXPERIMENT AND RESULT 5.1 Dataset We utilized LibriTTS dataset [90] to train the hierarchical speech synthesizer. First, we trained the model with trainclean subsets of LibriTTS (train-clean-100 and train-clean-360) for a fair comparison. Additionally, we utilized the trainother-500 subsets of LibriTTS for better voice style transfer. Furthermore, we scaled-up the dataset to 1 kh to improve the robustness and diversity, as indicated in TABLE 1[2] . For the Libri-light [27] and Multi-Speaker Speech Synthesis (MSSS) dataset of AIHub [3] , we sampled a small portion of speech from each speaker. We used a EXPRESSO [61] and NIKL[4]. We downsampled the audio at 16 kHz, and normalized it using a scale of [-0.95, 0.95]. For text-to-vec, we utilized all the train subsets of LibriTTS. For speechSR, we used a VCTK dataset [76] which has a sampling rate of 48 kHz to compare the models. However, we also trained the model with a largescale dataset for better speech super-resolution performance by including MSSS dataset, VCTK, and EXPRESSO. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. [2] Although we hope to increase the data scale to over 10k Hours, this is the maximum limit in our academic resources. [3] https://aihub.or.kr [4] https://www.nia.or.kr/ Authors:
(1) Sang-Hoon Lee, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea;
(2) Ha-Yeong Choi, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea;
(3) Seung-Bin Kim, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea;
(4) Seong-Whan Lee, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea and a Corresponding author. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Related Work 2.1 Neural Codec Language Models and 2.2 Non-autoregressive Models 2.1 Neural Codec Language Models and 2.2 Non-autoregressive Models 2.3 Diffusion Models and 2.4 Zero-shot Voice Cloning 2.3 Diffusion Models and 2.4 Zero-shot Voice Cloning 3 Hierspeech++ and 3.1 Speech Representations 3 Hierspeech++ and 3.1 Speech Representations 3.2 Hierarchical Speech Synthesizer 3.2 Hierarchical Speech Synthesizer 3.3 Text-to-Vec 3.3 Text-to-Vec 3.4 Speech Super-resolution 3.4 Speech Super-resolution 3.5 Model Architecture 3.5 Model Architecture 4 Speech Synthesis Tasks 4.1 Voice Conversion and 4.2 Text-to-Speech 4.1 Voice Conversion and 4.2 Text-to-Speech 4.3 Style Prompt Replication 4.3 Style Prompt Replication 5 Experiment and Result, and Dataset 5 Experiment and Result, and Dataset 5.2 Preprocessing and 5.3 Training 5.2 Preprocessing and 5.3 Training 5.4 Evaluation Metrics 5.4 Evaluation Metrics 5.5 Ablation Study 5.5 Ablation Study 5.6 Zero-shot Voice Conversion 5.6 Zero-shot Voice Conversion 5.7 High-diversity but High-fidelity Speech Synthesis 5.7 High-diversity but High-fidelity Speech Synthesis 5.8 Zero-shot Text-to-Speech 5.8 Zero-shot Text-to-Speech 5.9 Zero-shot Text-to-Speech with 1s Prompt 5.9 Zero-shot Text-to-Speech with 1s Prompt 5.10 Speech Super-resolution 5.10 Speech Super-resolution 5.11 Additional Experiments with Other Baselines 5.11 Additional Experiments with Other Baselines 6 Limitation and Quick Fix 6 Limitation and Quick Fix 7 Conclusion, Acknowledgement and References 7 Conclusion, Acknowledgement and References 5 EXPERIMENT AND RESULT 5.1 Dataset We utilized LibriTTS dataset [90] to train the hierarchical speech synthesizer. First, we trained the model with trainclean subsets of LibriTTS (train-clean-100 and train-clean-360) for a fair comparison. Additionally, we utilized the trainother-500 subsets of LibriTTS for better voice style transfer. Furthermore, we scaled-up the dataset to 1 kh to improve the robustness and diversity, as indicated in TABLE 1[2] . For the Libri-light [27] and Multi-Speaker Speech Synthesis (MSSS) dataset of AIHub [3] , we sampled a small portion of speech from each speaker. We used a EXPRESSO [61] and NIKL[4]. We downsampled the audio at 16 kHz, and normalized it using a scale of [-0.95, 0.95]. For text-to-vec, we utilized all the train subsets of LibriTTS. For speechSR, we used a VCTK dataset [76] which has a sampling rate of 48 kHz to compare the models. However, we also trained the model with a largescale dataset for better speech super-resolution performance by including MSSS dataset, VCTK, and EXPRESSO. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. available on arxiv [2] Although we hope to increase the data scale to over 10k Hours, this is the maximum limit in our academic resources. [3] https://aihub.or.kr https://aihub.or.kr [4] https://www.nia.or.kr/ https://www.nia.or.kr/ Authors: (1) Sang-Hoon Lee, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea; (2) Ha-Yeong Choi, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea; (3) Seung-Bin Kim, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea; (4) Seong-Whan Lee, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea and a Corresponding author. Authors: Authors: (1) Sang-Hoon Lee, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea; (2) Ha-Yeong Choi, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea; (3) Seung-Bin Kim, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea; (4) Seong-Whan Lee, Fellow, IEEE with the Department of Artificial Intelligence, Korea University, Seoul 02841, South Korea and a Corresponding author.

How We Used the LibriTTS Dataset to Train the Hierarchical Speech Synthesizer

Weather Image Recognition with AI: Dataset Labeling, Model Training, and Real-world Usecases

TON Hacker House Bangkok Draws 300+ Global Developers And 70+ Demo Submissions

TON Hacker House Bangkok atrae a más de 300 desarrolladores globales y más de 70 presentaciones de demostración

TON हैकर हाउस बैंकॉक ने 300+ वैश्विक डेवलपर्स और 70+ डेमो सबमिशन को आकर्षित किया

TON Hacker House Bangkok Menarik 300+ Pengembang Global dan 70+ Pengajuan Demo

TON ハッカーハウス バンコクに世界中の開発者 300 名以上が参加、デモの提出は 70 件以上

TON Hacker House Bangkok Menarik 300+ Pembangun Global Dan 70+ Penyerahan Demo

TON ह्याकर हाउस बैंककले 300+ ग्लोबल विकासकर्ताहरू र 70+ डेमो सबमिशनहरू आकर्षित गर्दछ

TON Hacker House Bangkok atrai mais de 300 desenvolvedores globais e mais de 70 envios de demonstração

ටොන් හැකර් හවුස් බැංකොක් ගෝලීය සංවර්ධකයින් 300+ සහ ආදර්ශන ඉදිරිපත් කිරීම් 70+ ඇද දමයි

TON Hacker House Bangkok 300+ Global Ösüşçiler we 70+ Demo Ibermelerini çekýär

TON Hacker House Bangkok 300'den Fazla Küresel Geliştiriciyi ve 70'ten Fazla Demo Gönderisini Bir Araya Getiriyor

TON Hacker House Bangkok Yi Koka 300+ wa Vatumbuluxi va Misava Hinkwayo Na 70+ wa Swirhumeriwa swa Demo

TON Hacker House Bangkok thu hút hơn 300 nhà phát triển toàn cầu và hơn 70 bài nộp bản demo

MLOps With Databricks and Spark - Part 1

Stories, News & Mentions about TRAINDOO

Traindoo’s Stories on HackerNoon