It briefly talks about the ML models trained to predict whether the parturients will require blood transfusion while undergoing cesarean section, published in 2024 on Nature.

Introduction

The amount of the blood loss during cesarian section and surgery is large and the transfusion requirement is not occasional, but a mendatory.

The good amount of blood preparation could save time cost intraoperatively. Blood is a scarce medical resource and it has to be significantly prepared with right amount so not to waste before surgery, thus accurately predicting the amount of blood is always demanded.

This paper articulates the data preparation and model comparison metrics and gives insight on which data to leverage for training ML models.

This paper mostly focuses on red blood cell excluding other blood products. The primary aim by the paper is to select the right ML model with the best performance in predicting the need for an intraoperative Red Blood Cell(RBC) transfusion during a CS.

Methods

The data could be divided into two parts: demographic data of the patient and perioperative data.

• Data

  • Data size

    • total: 16,137

    • used: 14,254 after excluding non-complete data

    • RBC transfusion during surgery: 1,020 patients (7.16% of the total)

    • data split: 6:2:2 for training, validation and test

  • the most recent data values within two days prior to surgery

    • demographic data

      • age, weight, height etc.

      • placenta previa totalis/partialis/marginalis

    • perioperative data

      • anesthesia, midazolam use, RBC transfusion

Data ratio for classification was particularly interesting to see. It is uncommon to apply imbalanced ratio to the number of ground truths. This paper compared by applying 1:1, 1:2..., 1:4 even.

• ML models

  • XGBoost, KNN, DT, SVM, MLP, LR, RF, DNN

• Model assessment

  • AUROC

  • AUPRC

  • metrics

    • accuracy, recall, precision, F1

Results

In accord with the paper, XGBoost most excel in the prediction for the blood transfusion with the score of AUROC 0.82 and Accuracy 0.94.

This figure compares ROC and PRC between each model.

But when I look at PRC curve, the recall values are too low that it the graph forms weird curves. Also the table above indicates that the F1 score is not greater than 0.5.

The figure below shows all ROC and PRC curves for different models with different dataset ratio.

Discussion

• 1:1 ratio dataset did not improve the performance of the model.

  • imbalanced dataset was better performed

• Traditional modeling can lead to degradation of performance where as ML aims for broader generalization and is adequate in this case

• Limits

  • single-center study

    • heterogeneous dataset could help generalizing the blood transfusion metrics which could enhance the model performance in general

  • needs more data balancing techniques for model training

    • by only selecting 1:1, 1:2..., 1:4 dataset ratio has a certain limit. This could confuse the model when the dataset is well-refined and well-polished.

Reflection

The research gave me a great range of insight when understanding medical data and how to apply models to it. However there were several moments when I felt the paper could be better in quality and have the models that could be utilized in the actual CR.

I would like to list a few things that I think will improve the performance of the models and settle down some limitations the paper mentioned.

• Recall score is extremely low, only precision is high

  • Well, I think this come from the data balance. The balance could be adjusted or the data itself could be normalized or preprocessed in advance. Raw data has a high risk as some features will carry a greater parameter for the model and this will affect the performance. The range generalization or trimming unnecessary data could help too.

  • The result indicates that the performance of XGBoost model excels but the recall score tells that the model is no use, even though the precision and accuracy metrics are high. This indicates that the model is highly biased towards predicting True Negative class as the best model trained with data ratio of True and False was not 1:1. This could imply that True Positive rate is extremely low, meaning when the parturients actually need blood transfusion, the model could say they will not need transfusion, which will increase the clinical risk.

• data split could be 8:1:1 to focus more on the training

  • The data lacked in the size. Only a 1-2 thousands of data rows could be considered to be used with 50:50 ratio for model training. To generalize the prediction performance with the scarce data could cause a highly biased result. If the dataset size is small, the training data rows should be more than 60%.

Reference

Lee, S. W., Park, B., Seo, J., Lee, S., & Sim, J. H. (2024). Development of a machine learning approach for prediction of red blood cell transfusion in patients undergoing Cesarean section at a single institution. Scientific Reports, 14, 16628. https://doi.org/10.1038/s41598-024-67784-2

If given a pdf file of a research paper, my first approach was to iterate each pages and feed the text data from a page to an agent. But an agent is stateless, meaning it does not have any information of the previous page and will cause data loss as some information is divided.

I, then, came up with an idea of a shared-memory as a state to be utilized by each agent in every step.

This paper’s goal is to enable the agents to perform a better reasoning and inference, also to reduce the inference time with less memory utilization.

1. Introduction

• Problem arisen from a traditional long context data processing with LLM

  • full-context prompting, appending all past turns regardless of their relevance

  • Growing inference cost and memory usage

  • Generalization limits beyond the training horizon

  • Overloaded and inefficient context

• Solution

  • a model to learn to consolidate its memory as part of its reasoning process

  • memory to be shared by agents

2. MEM1

• Annotate each component using XML-style tags

  • <IS> for internal state (reasoning)

    • summarizes past information

    • reasons about subsequent actions

  • <query> for environment queries

  • <answer> for the agent’s responses

  • <info> for external observations or tool outputs

The process indicates that the $IS_{t-1}$, $Query_{t-1}$, $Info_{t-1}$ are processed to be given to $IS_{t}$. In every step this process happens to get rid of the unnecessary data, which may affect the inference performance and data quality.

3. Experiment & Results

Interestingly, MEM1 approach showed the two key results

• better at inference time (less than others)

• better in match count

Reflection

In our research the entire MEM1 process is an excess approach, and also is a slightly different topic. However, it is notable that the paper represents the shared-memory technique to safely toss the data to the next agent and cast aside the incorrect data.

I will adapt the shared-memory in our pipeline, and the draft of the pipeline will look something like this.

It may not state everything in a accurate way but seems at least feasible to be applied to our research.

Also, when we consider training a model in our specific domain (Cognitive Reserve), I asked to myself, “Can we train in such a way?”, and came to a conclusion that I cannot as CR needs a specific dataset and cannot be trained and generalised.

Reference

[1] Zhou, Z., Qu, A., Wu, Z., Kim, S., Prakash, A., Rus, D., ... & Liang, P. P. (2025). MEM1: Learning to Synergize Memory and Reasoning for Efficient Long-Horizon Agents. arXiv preprint arXiv:2506.15841.

My company is now working on the Speech-to-Text skills and trying to catch up the state-of-the-art techniques to provide with the better quality services. Yet, there has been a lack of research and the stout background of STT knowledge, thus I picked several research papers including this paper. We need diarization as well to be able to specify the speaker as well as transcription. This paper helped in such way to understand how the architecture and algorithms should look like prior to building such service.

1. Abstract

The paper aims to fulfill Speech-to-Text tasks with speaker recognition, so called diarization leveraging Whisper model for transcription, ECAPA-TDNN for speaker embeddings, Agglomerative Hierarchical Clustering for speaker clustering to identify who spoke when.

2. Introduction

• why the paper do this research?

in modern society meeting transcription and audio processing are important. Yet the accuracy in audio processing needs improvement to be further developed to reach the service level.

• objects

  • identification and segmentation of speakers

  • content comprehension

• with what?

  • speaker embeddings

    • various acoustic features within speech

    • discern between speakers

Models and Packages

In this paper the research was conducted using Whisper model for transcription, Pyannote algorithm for speaker embeddings and Agglomerative Hierarchical Clustering for grouping similar embeddings. The key features in short are listed as below.

• Whisper

Whisper has been trained with multilingual supervised dataset to be able to differentiate languages, linguistic nuance and accents. It supports with many languages. Details to be mentioned later below.

• Pyannote

It is another model to extract and manipulate speaker embeddings. It encapsulates the unique sound characteristics of speakers. It is the key feature to diarize.

• Agglomerative Hierarchical Clustering

The embedded data will now then grouped into clusters using this algorithm, then it could be labeled.

in summary

• whisper: transcription of audio data

• pyannote: extract embeddings from acoustic features

• Agglomerative hierarchical clustering: unveil relationship between speakers

3. Related work

RNN and LSTM algorithm were utilized for Diarization research to understand the sequential features from the audio. However, there was a limitation in long sequential data. Also, CNN was used in such matter. It excelled in hierarchical spatial features and pattern extraction from spectrogram but had also a limit for variable data length (input size). After sometime when Transformers was released to the world, it was adapted for diarzation researches and applications as it performed well in many tasks.

Embeddings

To read the features for diarization, many researches were conducted. X-vectors is one of them and is introduced as the state-of-the-art algorithm (time delay neural network, so called TDNN) for speaker verification

Proposal

• to overcome the challenges and limitation stated above, this paper proposes the methodology of Emphasized Channel Attention, Propagation, and Aggregation (ECAPA-TDNN)

  • ECAPA-TDNN

    • an advanced iteration of TDNN

    • it uses

      • attention mechanism

      • multilayer feature aggregation (MFA)

      • squeeze excitation modules

      • residual blocks

k-means

efficient on large dataset, but has limitation when a speaker is dominant, but agglomerative hierarchical clustering can control such imbalances

4. Methodology

Whisper

The notable information about Whisper model is that, it is built with the transformer architecture with an encoder a decoder. It supports 99 languages with the word error rate (WER) of 4.2%. Korean has a lot more of a complexity in measuring the error rate and it cannot be measured by the WER as the spacing and letter combination system differ. Instead, character error rate is adopted to check the performance.

• 4.2% WER

• 99 languages

• 680,000h audio (online platform)

  • 563,000h english

  • 117,000h other languages

• robustness against accents, ambient disturbances

• currently has large-v3 and turbo model

• utilizes encoder-decoder transformer

  • encoder: derives a latent representation from speech

  • decoder: generates text, based on the latent representation

Other Speech-to-Text models

Suggested algorithm

Audio file is processed and handled in 16kHz PCM format scaled in a range of -1 to 1 normalized. Frequency is then converted using 80 channel Mel Spectrogram as 80 channel is most common and accepted by experience.

Encoder, decoder

• conversion involves

  • window size: 25ms

  • stride: 10ms

  • segments: 30s

• encoder operates per 30-second segment, to extract features

  • it involves two GELU activated convolutions

    • filter size of 3 for input embeddings

  • position embedding uses Sine function

    • performed by transformer

• decoder

  • calculates probability based on the latent representation

  • token determination via Greedy Search or Beak Search

  • output: maximum 224 tokens per 30-second segment

Process in short,

1. transcription

   • spoken content (Whisper)

2. speaker embeddings

   • speaker embeddings from audio (unique features of individuals)

     • bases for analysis

3. clustering

   • clustering using Agglomerative hierarchical clustering method based on similarity

4. output

   • will be able to see who spoke when

     • Whisper model’s output has time information with transcription

     • audio will be cut according to the time information and determines the speaker

Dataset

Paper used VoxCeleb1 and 2 dataset. This dataset was collected from Youtube of the celebrities. VoxCeleb dataset is the best usecase for many researches as it contains different voices from clear voices to voices with noise in the background.

Reflection

It was indeed intriguing and was informative for me to kick off in the STT field. However, what was lacking was that it gave less information about how the digitalized sound information was transformed into Mel-Spectrogram and data process. Overall the explanation about the process was a bit of a let-down.

Secondly, the paper shows the result data with two model comparison, yet it did not give the comparison data of train and test data error rate so to tell if the model was overfitted.

The algorithm of ECAPA-TDNN will be a good choice for diarization if the number of speaker is fixed in every situation. But in real life there is always a exception where in the meeting, another member comes in and the existing member could be out from the meeting. I personally think that the embeddings and clustering should consider such situation that the embedding information could change in any situation.

With such realization, next paper to read will be the very standard paper written by Oxford researchers who established VoxCeleb dataset. Or something else if there wil be any interesting paper

Reference

[1] R. D. Shankar, R. B. Manjula, and R. C. Biradar, "Revolutionizing Speaker Recognition and Diarization: A Novel Methodology in Speech Analysis," SN Computer Science, vol. 6, no. 87, 2025. https://doi.org/10.1007/s42979-024-03509-6

It had been only 3 days in the team since I joined the team, but I myself needed to figure out my pathway with which skills I will develop and carry.

There are tons and loads of AI domains I would like to get involved in, like algorithms making or linear regression research or LLMs, but since our team currently focuses on LLM and fine-tuning it, I decided to further study how to evaluate the LLM outputs and reinforcement-learn it.

OpenAI team Anthropic conducted a research on Reinforcement Learning from Human Feedback(RLHF) and it was intriguing.

1. Introduction

Learning from Human Feedback would mean nothing much difficult to understand. There are two datasets sorted by humans, and a model is fine-tuned.

Datasets

• Helpfulness

  • answering, writing, editing, documents etc.

• Harmlessness

  • not related to harmful goals like bank rubbery

These two datasets will be categorised by humans and it is totally up to the crowdworkers to decide which category the text falls into.

Trade-off

An interesting result though, when the model learns from a single dataset, which is either the helpful dataset or the harmless dataset, it has got a tendency to show the trade-offs in the scores.

As shown above, the green triangle plot(Online Helpful RLHF) scores top with Elo score on the left, yet on the right it is least preferred by crowdworkers when scoring for harmlessness. Technically, a bias is formed when only a single dataset is used for training the model.

When trained with the two datasets, both helpful and harmless datasets, it shows a meaningful result that the few-shot accuracy shows better performance than the zero-shot accuracy in general NLP performance tests.

The graphs indicate that the bigger models the better performance the models show in general.

2. Suggested RLHF

This is the process of RLHF from data collection to reinforcement learning. It was somehow complicated for me to understand the whole, so I had to summarise for my own the entire process according to my understanding. There are approximately three steps in a nutshell as below.

1) AB test

• crowdworker determines the outputs.

2) Preference Model

• input: prompt, AB answers, preferred answer(human feedback)

• output: scores

3) RLHF

• input: prompt, RLHF answer, PM score

3. Evaluation

The standard NLP test methods are applied to check the model, but as mentioned above, when the models are fine-tuned with the datasets (helpful and harmless), the bias is formed.

Test methods are as below.

• MMMLU: Benchmark for many domains with high-level questions (history, law, medicine, etc.)

• LAMBDA: A task to predict the last word

• HellaSwag: A task to choose an appropriate context

• OpenBookQA: Basic science knowledge

• ARC-Easy: Basic science knowledge (easy questions)

• ARC-Challenge: higher-level questions which requires the reasoning

• TriviaQA: common sense questions collected on the internet

4. Reflection

OpenAI team indicated that the model shows better performance in helpful scores, when evaluated by humans, but they are uncertain of the reason why it is like this. They assume it is because of the datasets, but further research is required to prove the datasets lack the correctness for fine-tuning.

Evaluation

It was always questioning me when I have to consider how to assess the model in a specific domain when an LLM is applied. Should a human give a feedback to the answers the LLM has given? Well, this paper at least had provided the information that humans (crowdworkers) did the job to divide datasets. From this research I could get the idea that human feedback is required and essential in output evaluation, although it is time consuming and requires budgets, because human force is the most expensive resource though.

Datasets

Dataset from the range of 100-500k will be ideal for fine-tuning, I though. The paper suggests the static datasets and online datasets, and the paper was released in 2022, which I think there could be better ideas and methods on how to make datasets using LLMs and evaluate them.

5. Reference

[1] Bai, Y., Jones, A., Ndousse, K., Askell, A., Chen, A., DasSarma, N., et al. (2022). Training a Helpful and Harmless Assistant with Reinforcement Learning from Human Feedback. arXiv preprint arXiv:2204.05862.

• has to be able to detect objects

• reads the environment and could tell it by the signal

• related to scanning the environment and able to visualize it

• low cost

Of course low cost for my personal project but it would be a different story if I were a part of the university in PhD course, which I am not, thus the cost matters.

I had a thorough review on this paper written by Turkish people, and according to this paper the authors belong to Defense Industries Research and Development Institute of Turkey, which gave me a belief that this paper would be meticulous and analytic.

1. Introduction

Why Ultrasonic sensor?

• Low cost compared to LIDAR

  The most and critical reason for utilizing ultrasonic sensing is because of the cost. Compared to ultrasonic sensor, other sensors are quite heavy in terms of price, LIDAR for example is a great sensor with a stunning visualization and detecting objects around, yet is high in price and individuals have impediments to access to this.

• Useful when optical sensing is not possible

  LIDAR, again, has the strength when the light can travel to objects. However, when optical sensing is disturbed by conditions such as weather or other factors, it may not be able to collect information from objects as there will be noise and the sensing tasks will not be fulfilled completely.

Aim

The paper aims to contribute to provide with the methodologies of 1) object classification and 2) coordinate estimation with a single ultrasonic sensor, so to be utilized on robotic or human applications such as helmets scanning objects in real time

2. Proposed methods

Data Collection

The authors placed the sensor on 3D printer for automated data collection. Every 2mm in X direction of the 3D printer, the data will be collected through ultrasonic sensor with 116 different scenarios.

Dataset

3 objects with 3 classes were to be used for dataset: large object (40mm), medium object (20mm) and narrow object (10 mm)

The process of the ultrasound sensor is as below.

1. Transmitter sends the signal to objects

2. Receiver takes the signal and process the signal through amplifier

3. Digitalize the signal

4. Send digital data to USB

Algorithm

CNN algorithm was applied to process the signal information. This was not a multi-modal model. Classic CNN model consists of 3 of 2D convolutional layers and 3 of max pooling layers, then flatten layer. Dense layer will take the vector feature and softmax will classify objects, and another dense layer will solve the linear regression for coordinates estimation.

Preprocessing

Data was collected by placing the objects at certain position in y-axis, and random between 0 - 40 cm in x-axis and measure every 2mm with ultrasonic sensor. 5mm is too much and miss out some information. The data then will look like a fluctuation on 2D graph where the object reflection is detected. Then envelope of the signal will be extracted from the raw data. When the two features are combined, a pillar-looking data shows on graph, seemingly very disheveled with a lot of noise.

Normalization

There are two normalization process.

• 0-255 to 0-1 scale

  This is necessary on image preprocessing so the model will take inputs with values from 0 to 1 and will not have big values to save memory of the machine as well as to prevent from overfitting as the value could grow intimidatingly when MSE is applied for error calculation.

• Change input size and and change to grayscale

  Size of the picture should be in a certain format such as 12 x 12 scale or other so the model will take the input accordingly. And also grayscale was applied to this algorithm.

3. Key Point

If divided into big categories, they will be as below.

• Data collection

• Data processing

• CNN to determine values

It focuses on CNN algorithm to perform multiple tasks and this differentiates the paper from other researches. Traditional CNN could perform such tasks with ultrasonic image data.

4. Reflection

The paper indeed is outstanding in details of how the data was prepared and the processing was done. It may be a barrier though, that if there is no knowledge about the sound waves, or graphs related to waves, and also the devices used for wave detection, this would be quite a handful paper to review. The paper introduces the modules and models of devices. Various kinds of these were new to me as I am not familiar with the sound wave or anything related to this domain.

I would need to see many studies of ultrasonic about environmental conditions like roads, metals or materials

Improvements

• Score

  The model itself was great in detecting objects and estimating the coordinates of objects. However, multiple object detection F1-score was unexpectedly low, although the first object showed over 90%. From the second object to multiple objects, the score would significantly decrease that some would score 79% in F1-score. The score could be said the model is adequately reliable with such performance, but also the score shows that there is a handful amount of error that this may not be appropriate for adaption in industries.

• Number of Sensor

  The aim of the paper is on the single-sensor algorithm. This was brilliant enough to show the possibility of object detection using only one ultrasonic sensor. However it has limitation when addressing many objects with a single sensor. As mentioned in the paper when Gaussian noise and salt-and-pepper noise were applied to the test dataset for real-world applications, the score would drop up to 70% for the third object. I strongly believe that using more sensors to this research will improve the quality of image processing and sensing data from the sensors.

• Test method

  I noticed that the test was conducted by placing objects at a certain y-axis, which is not at random points. This could be the limitation of the suggested method. I would be more reliable if the test was conducted with various position for x, y axis.

5. Reference

[1] Karagoz A., Dindis G., Object Recognition and Positioning with Neural Networks: Single Ultrasonic Sensor Scanning Approach, Sensors 2025, 25(4), 1086, https://doi.org/10.3390/s25041086 (CC BY 4.0)

I was not familiar with LLM’s algorithm and the computing resource usage of the LLMs. All I was doing was to utilise the LLM APIs for developers to build pipelines for automation. Other than that, nothing much was to consider.

When DeepSeek stroke the LLM industry, people eagerly talked about the algorithm and how light the model is compared to the other models such as GPT from OpenAI and Llama from Meta.

I would like to meticulously analyze DeepSeek, especially how it was designed to distill with open source models and how they used dataset to train the model.

1. Abstract

In the paper, two reasoning models are introduced: DeepSeek-R1-Zero and DeepSeek-R1. DeepSeek-R1-Zero seemed to be a model before supervised fine-tuning. In the abstract , two models are summarised with features below.

• DeepSeek-R1-Zero

  • without suvervised fine-tunining(SFT)

  • pros

    • remarkable reasoning capabilities

    • naturally emerges with numerous powerful and intriguing reasoning behaviors

  • cons

    • poor readability (human cannot understand the output)

    • poor language mixing

• DeepSeek-R1

  • developed to overcome the shortcomings of DeepSeek-R1-Zero

  • incorporates multi-stage training and cold-start data before RL.

  • comparable to OpenAI-o1-1217

According to the paper, the benchmark performance of DeepSeek-R1 surpasses OpenAI-o1-mini and show a similar performance with OpenAI-o1-1217. The performance metrics are as below in the table.

2. Introduction

In the paper, it kicks off by mentioning that OpenAI o1 was the first to be introduced for reasoning tasks but the effective test-time scaling is still challenged, and other works were not comparable to o1 models.

• Why was DeepSeek R1 model was developed?

  • To improve language model reasoning capabilities with RL(reinforcement learning)

• How?

  • DeepSeek-R1-Zero: DeepSeek-V3-Base's output pass through GRPO, to update parameters in accordance with the scores

  • DeepSeek-R1: RL and cold-start data, and multi stage training pipeline

Basically, this paper emphasises on the fact that LLM could be optimised and incentivised through RL without supervised fine-tuning(SFT)

3. Approach

In chapter 2, DeepSeek team mentions the algorithm, Group Relative Policy Optimisation (GRPO). This algorithm is utilised to train the model by optimising outputs, which consists of new policy and old policy. Also this paper says critic model is forgone. It is the same size as the policy model, which I think is one of the factors that enables the DeepSeek-R1-Zero to be lighter by reducing a significant amount of computational process.

GRPO equation looks as below.

The gist of the algorithm is to sample outputs from old policy and calculate possibilities. The ratio of new policy’s output and old policy’s output is then clipped within the range of \( 1-\\epsilon, 1+\\epsilon \) to prevent from getting too much bias either on the new policy or the old policy.

Rewards

There are two reward methods to which the model resort. The model will take the rewards when the output scores meaningfully. It leverages the rewards to update its weight in a direction where the score is evaluated good, whereas the less score will be then refined or ablated so only the useful scores remain.

• accuracy rewards: it evaluates the response like math problem results or classification results.

• format rewards: it enforces the model to have its reasoning process in the tags like '<think></think>'

How Test Was Done

• AIME accuracy: For each question, 16 answers were selected and the overall average accuracy was calculated

4. Key Point

DeepSeek-R1-Zero model showed that it actually is autonomously learning. The more learning steps it takes, the more time it takes to response, which means it thinks more before responding.

By its output after GRPO calculation, the model learns itself with knowledge it spits and takes it back to strengthen what it is sure about. It even reaches to the point where there is an "aha" moment, a moment when it realises itself what the knowledge should be or meant to be.

Yet still, DeekSeek-R1-Zero's reasoning process has the drawback of poor readability. If humans cannot understand the outputs from its weights, it will be useless. This is the reason why DeepSeek-R1 is designed to perform with robust readability.

DeepSeek-R1?

DeepSeek-R1 model takes a few data to be supervised-fine-tuned with the sampling data from DeepSeek-R1-Zero's output. Human annotators would filter and sample the data to be utilised or not utilised for DeepSeek-R1 model to be enforced to have better readability and reasoning ability. Approximately 600k reasoning related training samples and 200k unreasoning training samples were collected to feed the model.

Process in Summary

The process in this paper for reinforcement learning of the models is summarised as below.

• DeepSeek-V3-Base -> DeepSeek-R1-Zero -> DeepSeek-R1(with Zero's data for cold-start) -> DeepSeek-R1(with RL as Zero model did) -> Distillation

How Test Was Done

An intriguing part is the test part. There are many test methods for LLMs performance in unique domains like math, reasoning and others. The paper claims that 16 answers were selected and the overall average accuracy was calculated.

5. Reflection

This was my first LLM paper review. I felt awkward with the concepts of terms used in the paper like checkpoint, RL for LLM, rewards and so on. Quite a challenging moment it had been, and motivating to read the paper. It was also thrilling that the model could learn by itself by choosing rewards and taking the right output so it could develop its own universe of tensor. Once I had a doubt that the methodology of developing LLMs with vectors and tensors could be wrong and there are other ways to have a better performing models, but then realised that the numbers and floats in tensors are the best efficient way to store and calculate to reflect LLM and maybe it is by the nature meant to be this way. Number is the only way for now to express a data from a cell though.

Still there is a limitation that the model shows its robust part in English and Chinese since the base model was trained mainly with these two languages, but on the other hand, it was only the two languages it performed fancy. The paper mentions that the future work is to add more languages to the model so it is not restricted in only a few languages.

My personal interest in LLM, if there should be one, is making a sLLM, with low computational resource requirements, faster performance so it could be adopted in any circumstances whether it is on hardwares like embedding or any domains.

6. Reference

[1] DeepSeek-AI, Guo, D., Yang, D., Zhang, H., Song, J., Zhang, R., et al. (2024). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv preprint arXiv:2501.12948

An integer list of nums has numbers that could be either duplicate or non-duplicate. It is to leave 1-2 values for each number in the list in-place, which means it is nothing to do with returning any value from the method.

# example 1
Input: nums = [1, 1, 1, 2, 2, 3, 3, 4]
Output: nums = [1, 1, 2, 2, 3, 3, 4] # it is not a returned value. Must fix nums list from the parameter

Approach

I had an experience of removing duplicates from the given list. It was pretty much the same though. But this time it allowed each unique element to have 2 duplicates.

I was going to have the unique values with set() method and iterate from this.

Solution

The problem solving steps are as below.

1. I get the unique values into unique_n with set(nums)

2. Then I would check each element with n

3. If n has more duplicates than 2, remove in the while loop

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        unique_n = set(nums)
        for n in unique_n:
            while nums.count(n) > 2:
                nums.remove(n)

Reflection

This solution is not the best I could tell as the time complexity scored 4017ms! An amusing runtime number I had not seen before. There are two loops for and while, which will be close to O(n²) at worst.

People had it done in a different way with double pointer.

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:

        k = 2

        for i in range(2, len(nums)):
            if nums[i] != nums[k - 2]:
                nums[k] = nums[i]
                k += 1 

        return k

With this solution k-2th and ith index values are compared. The code could be visualised step by step like this.

# step 1
nums = [1, 1, 1, 2, 2, 3]
 idx => 0  1  2  3  4  5
        i     k
# i is 0 and k is at 2
# nums[i] != nums[k - 2] this condition is False

# step 2
nums = [1, 1, 1, 2, 2, 3]
 idx => 0  1  2  3  4  5
           i  k
# i is 1 and k is at 2
# nums[i] != nums[k - 2] this condition is False

# step 3
nums = [1, 1, 1, 2, 2, 3]
 idx => 0  1  2  3  4  5
              i
              k
# i is 2 and k is at 2
# nums[i] != nums[k - 2] this condition is False

# step 4
nums = [1, 1, 1, 2, 2, 3]
 idx => 0  1  2  3  4  5
              k  i
# i is 3 and k is at 2
# nums[i] != nums[k - 2] this condition is True
# nums[k] is updated, and k is updated
nums = [1, 1, 2, 2, 2, 3]
 idx => 0  1  2  3  4  5
                 k  i

This process goes until the end. It is quite a tricky algorithm without visualisation. With double pointers the time complexity will be close to O(n).

A string is given with spaces. The string could be a single character or a complete sentence. It is to reverse the string by words. The spaces at the edges should be cut off.

# example 1
Input: s = "the sky is blue"
Output: "blue is sky the"

# example 2
Input: s = "  the sky is blue  "
Output: "blue is sky the"

Approach

I would first make it a list, the reverse it. Quite a simple problem it seems.

Solution

I made the string a list by split() so it will automatically remove all the spaces and make a word list. s_list below will have the value s_list = [“the”, ”sky”, ”is”, ”blue”]. Afterwards, I reversed the list with s_list[::-1]. This index sorting means it will be reversed with the value -1. In slicing index has got the sequence as [start:stop:step]. When the step has a negative value, this means in a reverse order, so in our case it was to select every elements by emptying start and stop, then reverse it with -1 to enumerate every element.

When the list is reversed, then I simply joined the list.

class Solution:
    def reverseWords(self, s: str) -> str:
        s_list = s.split()
        return " ".join(s_list[::-1])

Reflection

If I had no knowledge about the internal methods like split(), join() and slicing technique, this problem would’ve been a conundrum. Luckily my answer had the time complexity of 0ms.

Given strings s and t, it is to tell whether s is the subsequence to t. It is not finding if the characters in s exist in t. Well basically it is, but the sequence matters too.

# example
Input: s = "abc", t = "ahbgdc"
Output: true

Approach

This would require a for loop to check each character. The loop will go through t as it may or may not contain s.

Solution

I have declared idx and initialized it with 0, to start from the first index of s. If only c from the loop of t is identical to s[idx], add up one to idx to move to the next sequence of s.

But it needs checking if idx is at the end of s. If it is at the end of s, there is no further need for checking the characters anymore, thus just return True.

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        idx = 0
        for c in t:
            if idx >= len(s):
                return True
            elif c == s[idx]:
                idx += 1

        if idx == len(s):
            return True
        return False

Reflection

The fact that I was trying to solve this with sort() or set() was a bit hilarious, but it was worth trying to see many test cases that went wrong with my code. It had 0ms time complexity which I am satisfied with.